Changeset 1041 for pykota/trunk/bin

Timestamp:

06/25/03 16:10:01 (21 years ago)

Author:

jalet

Message:

Hey, it may work (edpykota --reset excepted) !

Location:

pykota/trunk/bin

Files:

• edpykota (modified) (4 diffs)
• pykota (modified) (3 diffs)
• repykota (modified) (8 diffs)
• warnpykota (modified) (6 diffs)

pykota/trunk/bin/edpykota

@@ -23 +23 @@
 #
 # $Log$
+# Revision 1.47  2003/06/25 14:10:01  jalet
+# Hey, it may work (edpykota --reset excepted) !
+#
 # Revision 1.46  2003/06/16 11:59:09  jalet
 # More work on LDAP
@@ -330 +333 @@
     def main(self, names, options) :
         """Edit user or group quotas."""
-        printeradded = 0
-        printers = self.storage.getMatchingPrinters(options["printer"])
-        if not printers :
-            pname = options["printer"]
-            if options["add"] and pname :
-                if self.isValidName(pname) :
-                    printerid = self.storage.addPrinter(pname)
-                    printers = [ (printerid, pname) ]
-                    printeradded = 1
-                else :    
-                    raise PyKotaToolError, _("Invalid printer name %s") % pname
-            else :
-                raise PyKotaToolError, _("There's no printer matching %s") % pname
-                
+        
+        suffix = (options["groups"] and "Group") or "User"        
+        
         softlimit = hardlimit = None    
-        if options["softlimit"] :
-            try :
-                softlimit = int(options["softlimit"].strip())
-            except ValueError :    
-                raise PyKotaToolError, _("Invalid softlimit value %s.") % options["softlimit"]
-        if options["hardlimit"] :
-            try :
-                hardlimit = int(options["hardlimit"].strip())
-            except ValueError :    
-                raise PyKotaToolError, _("Invalid hardlimit value %s.") % options["hardlimit"]
-        if (softlimit is not None) and (hardlimit is not None) and (hardlimit < softlimit) :        
-            # error, exchange them
-            self.logger.log_message(_("Hard limit %i is less than soft limit %i, values will be exchanged.") % (hardlimit, softlimit))
-            (softlimit, hardlimit) = (hardlimit, softlimit)
+        if not options["noquota"] :
+            if options["softlimit"] :
+                try :
+                    softlimit = int(options["softlimit"].strip())
+                except ValueError :    
+                    raise PyKotaToolError, _("Invalid softlimit value %s.") % options["softlimit"]
+            if options["hardlimit"] :
+                try :
+                    hardlimit = int(options["hardlimit"].strip())
+                except ValueError :    
+                    raise PyKotaToolError, _("Invalid hardlimit value %s.") % options["hardlimit"]
+            if (softlimit is not None) and (hardlimit is not None) and (hardlimit < softlimit) :        
+                # error, exchange them
+                self.logger.log_message(_("Hard limit %i is less than soft limit %i, values will be exchanged.") % (hardlimit, softlimit))
+                (softlimit, hardlimit) = (hardlimit, softlimit)
             
-        if not names :    
-            if options["add"] and not printeradded :
-                raise PyKotaToolError, _("You have to pass user or group names on the command line")
-            else :    
-                names = [ "*" ] # all users
-                
         balance = options["balance"]
         if balance :
@@ -394 +381 @@
             groupnames = []
             
-        uwaschanged = {}         # tracks changed made at the user level
-        gwaschanged = {}         # tracks changed made at the group level
-        for (printerid, printer) in printers :
+        if options["prototype"] :    
+            protoentry = getattr(self.storage, "get%s" % suffix)(options["prototype"])
+            
+        printeradded = 0
+        printers = self.storage.getMatchingPrinters(options["printer"])
+        if not printers :
+            pname = options["printer"]
+            if options["add"] and pname :
+                if self.isValidName(pname) :
+                    printers = [ self.storage.addPrinter(pname) ]
+                    if printers[0].Exists :
+                        printeradded = 1
+                    else :    
+                        raise PyKotaToolError, _("Impossible to add printer %s") % pname
+                else :    
+                    raise PyKotaToolError, _("Invalid printer name %s") % pname
+            else :
+                raise PyKotaToolError, _("There's no printer matching %s") % pname
+        if not names :    
+            if options["add"] and not printeradded :
+                raise PyKotaToolError, _("You have to pass user or group names on the command line")
+            else :    
+                names = [ "*" ] # all users
+                
+        changed = {} # tracks changes made at the user/group level
+        for printer in printers :
             if options["charge"] :
                 (perpage, perjob) = charges
-                if perjob is None :
-                    # we don't want to change this one, get the old value
-                    (dummy, perjob) = self.storage.getPrinterPrices(printerid)
-                self.storage.setPrinterPrices(printerid, perpage, perjob)    
+                printer.setPrices(perpage, perjob)    
+                
             if options["prototype"] :
-                if options["groups"] :
-                    prototype = self.storage.getGroupPQuota(self.storage.getGroupId(options["prototype"]), printerid)
-                else :     
-                    # default is user quota edition
-                    prototype = self.storage.getUserPQuota(self.storage.getUserId(options["prototype"]), printerid)
-                if prototype is None :
-                    self.logger.log_message(_("Prototype %s not found in Quota Storage for printer %s.") % (options["prototype"], printer))
-                    continue    # skip this printer
-                else :    
-                    (softlimit, hardlimit) = (prototype["softlimit"], prototype["hardlimit"])
-            if hardlimit is None :    
-                hardlimit = softlimit
-                if hardlimit is not None :
-                    self.logger.log_message(_("Undefined hard limit set to soft limit (%s) on printer %s.") % (str(hardlimit), printer))
-            if softlimit is None :    
-                softlimit = hardlimit
-                if softlimit is not None :
-                    self.logger.log_message(_("Undefined soft limit set to hard limit (%s) on printer %s.") % (str(softlimit), printer))
-            if (not options["ingroups"] and not options["reset"] and not options["noquota"] and not options["prototype"] and not options["limitby"] and not options["balance"] and not options["delete"] and not options["charge"]) and ((hardlimit is None) or (softlimit is None)) :
-                raise PyKotaToolError, _("Both hard and soft limits must be set ! Aborting.")
+                if protoentry.Exists :
+                    protoquota = getattr(self.storage, "get%PQuota" % suffix)(protoentry, printer)
+                    if not protoquota.Exists :
+                        self.logger.log_message(_("Prototype %s not found in Quota Storage for printer %s.") % (protoentry.Name, printer.Name))
+                        continue    # skip this printer
+                    else :    
+                        (softlimit, hardlimit) = (protoquota.SoftLimit, protoquota.HardLimit)
+                else :        
+                    self.logger.log_message(_("Prototype object %s not found in Quota Storage.") % protoentry.Name)
+            if not options["noquota"] :    
+                if hardlimit is None :    
+                    hardlimit = softlimit
+                    if hardlimit is not None :
+                        self.logger.log_message(_("Undefined hard limit set to soft limit (%s) on printer %s.") % (str(hardlimit), printer.Name))
+                if softlimit is None :    
+                    softlimit = hardlimit
+                    if softlimit is not None :
+                        self.logger.log_message(_("Undefined soft limit set to hard limit (%s) on printer %s.") % (str(softlimit), printer.Name))
+                        
             if options["add"] :    
-                if options["groups"] :    
-                    allidnames = [(self.storage.getGroupId(n), n) for n in names]
-                else :
-                    allidnames = [(self.storage.getUserId(n), n) for n in names]
+                allentries = []    
+                for name in names :
+                    entry = getattr(self.storage, "get%s" % suffix)(name)
+                    entrypquota = getattr(self.storage, "get%sPQuota" % suffix)(entry, printer)
+                    allentries.append((entry, entrypquota))
             else :   
-                if options["groups"] :    
-                    allidnames = self.storage.getPrinterGroups(printerid) or []
-                else :    
-                    allidnames = self.storage.getPrinterUsers(printerid) or []
-            for (ident, name) in [(i, n) for (i, n) in allidnames if self.matchString(n, names)]:
-                if options["groups"] :
-                    if not gwaschanged.has_key(name) :
-                        gwaschanged[name] = {}
-                    quota = self.storage.getGroupPQuota(ident, printerid)
-                else :
-                    if not uwaschanged.has_key(name) :
-                        uwaschanged[name] = {"ingroups": []}
-                    quota = self.storage.getUserPQuota(ident, printerid)
-                if quota is None :
+                allentries = getattr(self.storage, "getPrinter%ssAndQuotas" % suffix)(printer)
+                
+            for (entry, entrypquota) in [(e, q) for (e, q) in allentries if self.matchString(e.Name, names)] :
+                if not changed.has_key(entry.Name) :
+                    changed[entry.Name] = {}
+                if not entrypquota.Exists :
                     # not found
                     if options["add"] :
@@ -450 +450 @@
                         # like /etc/passwd because users may be defined 
                         # only remotely
-                        if options["groups"] :
-                            if self.isValidName(name) :
-                                (ident, printerid) = self.storage.addGroupPQuota(name, printerid)
-                                quota = self.storage.getGroupPQuota(ident, printerid)
+                        if self.isValidName(entry.Name) :
+                            if not entry.Exists :
+                                entry = getattr(self.storage, "add%s" % suffix)(entry)
+                            entrypquota = getattr(self.storage, "add%sPQuota" % suffix)(entry, printer)
+                        else :    
+                            if options["groups"] :
+                                self.logger.log_message(_("Invalid group name %s") % entry.Name)
                             else :    
-                                self.logger.log_message(_("Invalid group name %s") % name)
-                        else :
-                            if self.isValidName(name) :
-                                (ident, printerid) = self.storage.addUserPQuota(name, printerid)
-                                quota = self.storage.getUserPQuota(ident, printerid)
-                            else :    
-                                self.logger.log_message(_("Invalid user name %s") % name)
-                if quota is None :     
-                    self.logger.log_message(_("Quota not found for object %s on printer %s.") % (name, printer))
+                                self.logger.log_message(_("Invalid user name %s") % entry.Name)
+                if not entrypquota.Exists :     
+                    self.logger.log_message(_("Quota not found for object %s on printer %s.") % (entry.Name, printer.Name))
                 else :    
                     if options["delete"] :
-                        if options["groups"] :
-                            self.storage.deleteGroup(ident)
-                        else :
-                            self.storage.deleteUser(ident)
+                        entry.delete()
                     else :
-                        if options["groups"] :
-                            if options["noquota"] or options["prototype"] or ((softlimit is not None) and (hardlimit is not None)) :
-                                self.storage.setGroupPQuota(ident, printerid, softlimit, hardlimit)
+                        if options["noquota"] or options["prototype"] or ((softlimit is not None) and (hardlimit is not None)) :
+                            entrypquota.setLimits(softlimit, hardlimit)
+                        if limitby :
+                            if changed[entry.Name].get("limitby") is None :
+                                entry.setLimitBy(limitby)
+                                changed[entry.Name]["limitby"] = limitby
+                        
+                        if not options["groups"] :
                             if options["reset"] :
-                                self.storage.resetGroupPQuota(ident, printerid)
-                            if limitby :
-                                if gwaschanged[name].get("limitby") is None :
-                                    self.storage.limitGroupBy(ident, limitby)
-                                    gwaschanged[name]["limitby"] = limitby
-                            self.warnGroupPQuota(name, printer)    
-                        else :
-                            if options["noquota"] or options["prototype"] or ((softlimit is not None) and (hardlimit is not None)) :
-                                self.storage.setUserPQuota(ident, printerid, softlimit, hardlimit)
-                            if options["reset"] :
-                                self.storage.resetUserPQuota(ident, printerid)
-                            if limitby :
-                                if uwaschanged[name].get("limitby") is None :
-                                    self.storage.limitUserBy(ident, limitby)
-                                    uwaschanged[name]["limitby"] = limitby
+                                entrypquota.reset()
+                                
                             if balance :
-                                if uwaschanged[name].get("balance") is None :
+                                if changed[entry.Name].get("balance") is None :
                                     if balance.startswith("+") or balance.startswith("-") :
-                                        self.storage.increaseUserBalance(ident, balancevalue)
+                                        entry.consumeAccountBalance(-balancevalue)
                                     else :
-                                        self.storage.setUserBalance(ident, balancevalue)
-                                    uwaschanged[name]["balance"] = balance
+                                        entry.consumeAccountBalance(float(entry.AccountBalance or 0.0) - balancevalue)
+                                    changed[entry.Name]["balance"] = balance
                             for groupname in groupnames :        
-                                if groupname not in uwaschanged[name]["ingroups"] :
-                                    groupid = self.storage.getGroupId(groupname)
-                                    if groupid is not None :
-                                        self.storage.addUserToGroup(ident, groupid)
-                                        uwaschanged[name]["ingroups"].append(groupname)
+                                if groupname not in changed[name]["ingroups"] :
+                                    group = self.storage.getGroup(groupname)
+                                    if group.Exists :
+                                        self.storage.addUserToGroup(entry, group)
+                                        changed[entry.Name]["ingroups"].append(groupname)
                                     else :
                                         self.logger.log_message(_("Group %s not found in the PyKota Storage.") % groupname)
-                            self.warnUserPQuota(name, printer)    
+                                        
+                        getattr(self, "warn%sPQuota" % suffix)(entrypquota)    
                      
 if __name__ == "__main__" : 

pykota/trunk/bin/pykota

@@ -23 +23 @@
 #
 # $Log$
+# Revision 1.35  2003/06/25 14:10:01  jalet
+# Hey, it may work (edpykota --reset excepted) !
+#
 # Revision 1.34  2003/06/13 18:54:17  jalet
 # Bug with remote jobs and LPRng fixed.
@@ -239 +242 @@
     
     # Get the last page counter and last username from the Quota Storage backend
-    printerid = kotafilter.storage.getPrinterId(kotafilter.printername)
-    if printerid is None :
+    printer = kotafilter.storage.getPrinter(kotafilter.printername)
+    if not printer.Exists :
         # The printer is unknown from the Quota Storage perspective
         # we let the job pass through, but log a warning message
         kotafilter.logger.log_message(_("Printer %s not registered in the PyKota system") % kotafilter.printername, "warn")
     else :    
-        userid = kotafilter.storage.getUserId(kotafilter.username)
-        if userid is None :
+        user = kotafilter.storage.getUser(kotafilter.username)
+        if not user.Exists :
             # The user is unknown from the Quota Storage perspective
             # Depending on the default policy for this printer, we
@@ -261 +264 @@
         else :
             # Now does the accounting and act depending on the result
-            action = kotafilter.accounter.doAccounting(printerid, userid)
+            action = kotafilter.accounter.doAccounting(printer, user)
             
             # if not allowed to print then die, else proceed.

pykota/trunk/bin/repykota

@@ -23 +23 @@
 #
 # $Log$
+# Revision 1.39  2003/06/25 14:10:01  jalet
+# Hey, it may work (edpykota --reset excepted) !
+#
 # Revision 1.38  2003/06/15 22:26:52  jalet
 # More work on LDAP
@@ -147 +150 @@
 
 import sys
+import os
+import pwd
+import grp
 
 from mx import DateTime
@@ -187 +193 @@
   
   This will print the quota status for all users on all printers.
+  
+  $ repykota --printer "laser*" jerome "jo*"
+  
+  This will print the quota status for user jerome and all users
+  whose name begins with "jo" on all printers which name begin
+  with "laser"
+  
+  If launched by a non-root user, additionnal arguments representing
+  users or groups names are ignored, and only the current user/group
+  is reported.
 
 This program is free software; you can redistribute it and/or modify
@@ -206 +222 @@
 class RePyKota(PyKotaTool) :        
     """A class for repykota."""
-    def main(self, options) :
+    def main(self, ugnames, options) :
         """Print Quota reports generator."""
+        uid = os.geteuid()
+        if not uid :
+            # root user
+            if not ugnames :
+                # no username, means all usernames
+                ugnames = [ "*" ]
+        else :        
+            # not the root user
+            # reports only the current user
+            if options["groups"] :
+                ugnames = [ grp.getgrgid(pwd.getpwuid(uid)[3])[0] ]
+            else :
+                ugnames = [ pwd.getpwuid(uid)[0] ]
+        
         printers = self.storage.getMatchingPrinters(options["printer"])
         if not printers :
             raise PyKotaToolError, _("There's no printer matching %s") % options["printer"]
-        for (printerid, printer) in printers :
-            print _("*** Report for %s quota on printer %s") % ((options["groups"] and "group") or "user", printer)
-            print _("Pages grace time: %i days") % self.config.getGraceDelay(printer)
-            prices = self.storage.getPrinterPrices(printerid)
-            if prices is None :
-                (perpage, perjob) = (None, None)
-            else :    
-                (perpage, perjob) = prices
-            if perjob is not None :
-                print _("Price per job: %.3f") % perjob
-            if perpage is not None :    
-                print _("Price per page: %.3f") % perpage
+        for printer in printers :
+            print _("*** Report for %s quota on printer %s") % ((options["groups"] and "group") or "user", printer.Name)
+            print _("Pages grace time: %i days") % self.config.getGraceDelay(printer.Name)
+            if printer.PricePerJob is not None :
+                print _("Price per job: %.3f") % printer.PricePerJob
+            if printer.PricePerPage is not None :    
+                print _("Price per page: %.3f") % printer.PricePerPage
             total = 0
             totalmoney = 0.0
@@ -228 +253 @@
                 print _("Group           used    soft    hard    balance grace         total       paid") 
                 print "------------------------------------------------------------------------------"
-                for (ident, name) in (self.storage.getPrinterGroups(printerid) or []) :
-                    quota = self.storage.getGroupPQuota(ident, printerid) 
-                    balance = self.storage.getGroupBalance(ident)
-                    limitby = self.storage.getGroupLimitBy(ident)
-                    (pages, money) = self.printQuota(name, quota, balance, limitby)
+                for (group, grouppquota) in self.storage.getPrinterGroupsAndQuotas(printer, ugnames) :
+                    (pages, money) = self.printQuota(group, grouppquota)
                     total += pages
                     totalmoney += money
@@ -239 +261 @@
                 print _("User            used    soft    hard    balance grace         total       paid") 
                 print "------------------------------------------------------------------------------"
-                for (ident, name) in (self.storage.getPrinterUsers(printerid) or []) :
-                    quota = self.storage.getUserPQuota(ident, printerid)
-                    balance = self.storage.getUserBalance(ident)
-                    limitby = self.storage.getUserLimitBy(ident)
-                    (pages, money) = self.printQuota(name, quota, balance, limitby)
+                for (user, userpquota) in self.storage.getPrinterUsersAndQuotas(printer, ugnames) :
+                    (pages, money) = self.printQuota(user, userpquota)
                     total += pages
                     totalmoney += money
             if total or totalmoney :        
                 print (" " * 50) + (_("Total : %9i") % total) + ("%11s" % ("%7.2f" % totalmoney)[:11])
-            printerpagecounter = self.storage.getPrinterPageCounter(printerid)
             try :
-                msg = "%9i" % printerpagecounter["pagecounter"]
+                msg = "%9i" % printer.LastJob.PrinterPageCounter
             except TypeError :     
                 msg = _("unknown")
@@ -258 +276 @@
             print _("Totals may be inaccurate if some users are members of several groups.")
                         
-    def printQuota(self, name, quota, balance, limitby) :
+    def printQuota(self, entry, quota) :
         """Prints the quota information."""
-        if quota is not None :
-            lifepagecounter = quota["lifepagecounter"] or 0
-            pagecounter = quota["pagecounter"] or 0
-            softlimit = quota["softlimit"]
-            hardlimit = quota["hardlimit"]
-            datelimit = quota["datelimit"]
-            if balance is not None :
-                (balance, lifetimepaid) = balance
-            else :    
-                (balance, lifetimepaid) = (0.0, 0.0)
-            if datelimit is not None :
-                now = DateTime.now()
-                datelimit = DateTime.ISO.ParseDateTime(datelimit)
-                if now >= datelimit :
-                    datelimit = "DENY"
-            else :    
-                datelimit = ""
-            if limitby == "balance" :    
-                reached = (((balance <= 0) and "+") or "-") + "B"
-            else :
-                reached = (((softlimit is not None) and (pagecounter >= softlimit) and "+") or "-") + "Q"
-            balance = balance or 0.0    
-            lifetimepaid = lifetimepaid or 0.0
-            strbalance = ("%5.2f" % balance)[:10]
-            strlifetimepaid = ("%6.2f" % lifetimepaid)[:10]
-            print "%-9.9s %s %7i %7s %7s %10s %-10.10s %8i %10s" % (name, reached, pagecounter, str(softlimit), str(hardlimit), strbalance, str(datelimit)[:10], lifepagecounter, strlifetimepaid)
-            return (lifepagecounter, lifetimepaid)
+        lifepagecounter = int(quota.LifePageCounter or 0)
+        pagecounter = int(quota.PageCounter or 0)
+        balance = float(entry.AccountBalance or 0.0)
+        lifetimepaid = float(entry.LifeTimePaid or 0.0)
+        
+        if quota.DateLimit is not None :
+            now = DateTime.now()
+            datelimit = DateTime.ISO.ParseDateTime(quota.DateLimit)
+            if now >= datelimit :
+                datelimit = "DENY"
+        elif (quota.HardLimit is not None) and (pagecounter >= quota.HardLimit) :    
+            datelimit = "DENY"
+        elif (quota.HardLimit is None) and (quota.SoftLimit is not None) and (pagecounter >= quota.SoftLimit) :
+            datelimit = "DENY"
         else :    
-            return (0, 0)
-        
+            datelimit = ""
+            
+        if entry.LimitBy.lower() == "balance" :    
+            reached = (((balance <= 0) and "+") or "-") + "B"
+        else :
+            reached = (((quota.SoftLimit is not None) and (pagecounter >= quota.SoftLimit) and "+") or "-") + "Q"
+            
+        strbalance = ("%5.2f" % balance)[:10]
+        strlifetimepaid = ("%6.2f" % lifetimepaid)[:10]
+        print "%-9.9s %s %7i %7s %7s %10s %-10.10s %8i %10s" % (entry.Name, reached, pagecounter, str(quota.SoftLimit), str(quota.HardLimit), strbalance, str(datelimit)[:10], lifepagecounter, strlifetimepaid)
+        return (lifepagecounter, lifetimepaid)
                     
 if __name__ == "__main__" : 
@@ -318 +332 @@
         elif options["users"] and options["groups"] :    
             raise PyKotaToolError, _("incompatible options, see help.")
-        elif args :    
-            raise PyKotaToolError, _("unused arguments [%s]. Aborting.") % ", ".join(args)
         else :
-            sys.exit(reporter.main(options))
+            sys.exit(reporter.main(args, options))
     except (PyKotaToolError, PyKotaConfigError, PyKotaStorageError), msg :            
         sys.stderr.write("%s\n" % msg)

pykota/trunk/bin/warnpykota

@@ -23 +23 @@
 #
 # $Log$
+# Revision 1.20  2003/06/25 14:10:01  jalet
+# Hey, it may work (edpykota --reset excepted) !
+#
 # Revision 1.19  2003/04/29 22:03:38  jalet
 # Better error handling.
@@ -84 +87 @@
 
 import sys
+import os
+import pwd
+import grp
 
 from pykota import version
@@ -96 +102 @@
 command line usage :
 
-  warnpykota [options] 
+  warnpykota  [options]  [names]
 
 options :
@@ -125 +131 @@
   any printer.
 
-  $ warnpykota --groups --printer "laserjet*"
-  
-  This will warn all users of groups which have exceeded 
-  their print quota on any printer which name begins with "laserjet"
+  $ warnpykota --groups --printer "laserjet*" "dev*"
+  
+  This will warn all users of groups which names begins with "dev" and
+  who have exceeded their print quota on any printer which name begins 
+  with "laserjet"
+  
+  If launched by a non-root user, additionnal arguments representing
+  users or groups names are ignored, and only the current user/group
+  is warned.
 
 This program is free software; you can redistribute it and/or modify
@@ -148 +159 @@
 class WarnPyKota(PyKotaTool) :        
     """A class for warnpykota."""
-    def main(self, options) :
+    def main(self, ugnames, options) :
         """Warn users or groups over print quota."""
+        uid = os.geteuid()
+        if not uid :
+            # root user
+            if not ugnames :
+                # no username, means all usernames
+                ugnames = [ "*" ]
+        else :        
+            # not the root user
+            # warns only the current user
+            # the utility of this is discutable, but at least it
+            # protects other users from mail bombing if they are
+            # over quota.
+            if options["groups"] :
+                ugnames = [ grp.getgrgid(pwd.getpwuid(uid)[3])[0] ]
+            else :
+                ugnames = [ pwd.getpwuid(uid)[0] ]
+        
         printers = self.storage.getMatchingPrinters(options["printer"])
         if not printers :
             raise PyKotaToolError, _("There's no printer matching %s") % options["printer"]
-        for (printerid, printer) in printers :
+        for printer in printers :
             if options["groups"] :
-                for (ident, name) in self.storage.getPrinterGroups(printerid) :
-                    self.warnGroupPQuota(name, printer)
+                for (group, grouppquota) in self.storage.getPrinterGroupsAndQuotas(printer, ugnames) :
+                    self.warnGroupPQuota(grouppquota)
             else :
-                for (ident, name) in self.storage.getPrinterUsers(printerid) :
-                    self.warnUserPQuota(name, printer)
+                for (user, userpquota) in self.storage.getPrinterUsersAndQuotas(printer, ugnames) :
+                    self.warnUserPQuota(userpquota)
                      
 if __name__ == "__main__" : 
@@ -188 +216 @@
         elif options["users"] and options["groups"] :    
             raise PyKotaToolError, _("incompatible options, see help.")
-        elif args :    
-            raise PyKotaToolError, _("unused arguments [%s]. Aborting.") % ", ".join(args)
         else :
-            sys.exit(sender.main(options))
+            sys.exit(sender.main(args, options))
     except (PyKotaToolError, PyKotaConfigError, PyKotaStorageError), msg :            
         sys.stderr.write("%s\n" % msg)