root / pykota / trunk / pykota / config.py @ 2147

Revision 2147, 19.9 kB (checked in by jerome, 19 years ago)

Removed all references to $Log$

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1# PyKota
2# -*- coding: ISO-8859-15 -*-
3#
4# PyKota : Print Quotas for CUPS and LPRng
5#
6# (c) 2003-2004 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 2 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, write to the Free Software
19# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
20#
21# $Id$
22#
23#
24
25import os
26import ConfigParser
27
28class PyKotaConfigError(Exception):
29    """An exception for PyKota config related stuff."""
30    def __init__(self, message = ""):
31        self.message = message
32        Exception.__init__(self, message)
33    def __repr__(self):
34        return self.message
35    __str__ = __repr__
36   
37class PyKotaConfig :
38    """A class to deal with PyKota's configuration."""
39    def __init__(self, directory) :
40        """Reads and checks the configuration file."""
41        self.isAdmin = 0
42        self.directory = directory
43        self.filename = os.path.join(directory, "pykota.conf")
44        if not os.path.isfile(self.filename) :
45            raise PyKotaConfigError, _("Configuration file %s not found.") % self.filename
46        self.config = ConfigParser.ConfigParser()
47        self.config.read([self.filename])
48           
49    def isTrue(self, option) :       
50        """Returns 1 if option is set to true, else 0."""
51        if (option is not None) and (option.upper().strip() in ['Y', 'YES', '1', 'ON', 'T', 'TRUE']) :
52            return 1
53        else :   
54            return 0
55                       
56    def getPrinterNames(self) :   
57        """Returns the list of configured printers, i.e. all sections names minus 'global'."""
58        return [pname for pname in self.config.sections() if pname != "global"]
59       
60    def getGlobalOption(self, option, ignore=0) :   
61        """Returns an option from the global section, or raises a PyKotaConfigError if ignore is not set, else returns None."""
62        try :
63            return self.config.get("global", option, raw=1)
64        except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) :   
65            if ignore :
66                return
67            else :
68                raise PyKotaConfigError, _("Option %s not found in section global of %s") % (option, self.filename)
69               
70    def getPrinterOption(self, printername, option) :   
71        """Returns an option from the printer section, or the global section, or raises a PyKotaConfigError."""
72        globaloption = self.getGlobalOption(option, ignore=1)
73        try :
74            return self.config.get(printername, option, raw=1)
75        except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) :   
76            if globaloption is not None :
77                return globaloption
78            else :
79                raise PyKotaConfigError, _("Option %s not found in section %s of %s") % (option, printername, self.filename)
80       
81    def getStorageBackend(self) :   
82        """Returns the storage backend information as a Python mapping."""       
83        backendinfo = {}
84        for option in [ "storagebackend", "storageserver", \
85                        "storagename", "storageuser", \
86                      ] :
87            backendinfo[option] = self.getGlobalOption(option)
88        backendinfo["storageuserpw"] = self.getGlobalOption("storageuserpw", ignore=1)  # password is optional
89        backendinfo["storageadmin"] = None
90        backendinfo["storageadminpw"] = None
91        adminconf = ConfigParser.ConfigParser()
92        filename = os.path.join(self.directory, "pykotadmin.conf")
93        adminconf.read([filename])
94        if adminconf.sections() : # were we able to read the file ?
95            try :
96                backendinfo["storageadmin"] = adminconf.get("global", "storageadmin", raw=1)
97            except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) :   
98                raise PyKotaConfigError, _("Option %s not found in section global of %s") % ("storageadmin", filename)
99            else :   
100                self.isAdmin = 1 # We are a PyKota administrator
101            try :
102                backendinfo["storageadminpw"] = adminconf.get("global", "storageadminpw", raw=1)
103            except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) :   
104                pass # Password is optional
105        return backendinfo
106       
107    def getLDAPInfo(self) :   
108        """Returns some hints for the LDAP backend."""       
109        ldapinfo = {}
110        for option in [ "userbase", "userrdn", \
111                        "balancebase", "balancerdn", \
112                        "groupbase", "grouprdn", "groupmembers", \
113                        "printerbase", "printerrdn", \
114                        "userquotabase", "groupquotabase", \
115                        "jobbase", "lastjobbase", \
116                        "newuser", "newgroup", \
117                        "usermail", \
118                      ] :
119            ldapinfo[option] = self.getGlobalOption(option).strip()
120        for field in ["newuser", "newgroup"] :
121            if ldapinfo[field].lower().startswith('attach(') :
122                ldapinfo[field] = ldapinfo[field][7:-1]
123               
124        # should we use TLS, by default (if unset) value is NO       
125        ldapinfo["ldaptls"] = self.isTrue(self.getGlobalOption("ldaptls", ignore=1))
126        ldapinfo["cacert"] = self.getGlobalOption("cacert", ignore=1)
127        if ldapinfo["cacert"] :
128            ldapinfo["cacert"] = ldapinfo["cacert"].strip()
129        if ldapinfo["ldaptls"] :   
130            if not os.access(ldapinfo["cacert"] or "", os.R_OK) :
131                raise PyKotaConfigError, _("Option ldaptls is set, but certificate %s is not readable.") % str(ldapinfo["cacert"])
132        return ldapinfo
133       
134    def getLoggingBackend(self) :   
135        """Returns the logging backend information."""
136        validloggers = [ "stderr", "system" ] 
137        try :
138            logger = self.getGlobalOption("logger").lower()
139        except PyKotaConfigError :   
140            logger = "system"
141        if logger not in validloggers :             
142            raise PyKotaConfigError, _("Option logger only supports values in %s") % str(validloggers)
143        return logger   
144       
145    def getAccounterBackend(self, printername) :   
146        """Returns the accounter backend to use for a given printer.
147       
148           if it is not set, it defaults to 'hardware' which means ask printer
149           for its internal lifetime page counter.
150        """   
151        validaccounters = [ "hardware", "software" ]     
152        fullaccounter = self.getPrinterOption(printername, "accounter").strip()
153        flower = fullaccounter.lower()
154        if flower.startswith("software") or flower.startswith("hardware") :   
155            try :
156                (accounter, args) = [x.strip() for x in fullaccounter.split('(', 1)]
157            except ValueError :   
158                raise PyKotaConfigError, _("Invalid accounter %s for printer %s") % (fullaccounter, printername)
159            if args.endswith(')') :
160                args = args[:-1].strip()
161            if (accounter == "hardware") and not args :
162                raise PyKotaConfigError, _("Invalid accounter %s for printer %s") % (fullaccounter, printername)
163            return (accounter.lower(), args)   
164        else :
165            raise PyKotaConfigError, _("Option accounter in section %s only supports values in %s") % (printername, str(validaccounters))
166       
167    def getPreHook(self, printername) :   
168        """Returns the prehook command line to launch, or None if unset."""
169        try :
170            return self.getPrinterOption(printername, "prehook").strip()
171        except PyKotaConfigError :   
172            return      # No command to launch in the pre-hook
173           
174    def getPostHook(self, printername) :   
175        """Returns the posthook command line to launch, or None if unset."""
176        try :
177            return self.getPrinterOption(printername, "posthook").strip()
178        except PyKotaConfigError :   
179            return      # No command to launch in the post-hook
180           
181    def getPrinterEnforcement(self, printername) :   
182        """Returns if quota enforcement should be strict or laxist for the current printer."""
183        validenforcements = [ "STRICT", "LAXIST" ]     
184        try :
185            enforcement = self.getPrinterOption(printername, "enforcement")
186        except PyKotaConfigError :   
187            return "LAXIST"
188        else :   
189            enforcement = enforcement.upper()
190            if enforcement not in validenforcements :
191                raise PyKotaConfigError, _("Option enforcement in section %s only supports values in %s") % (printername, str(validenforcements))
192            return enforcement   
193           
194    def getPrinterOnAccounterError(self, printername) :   
195        """Returns what must be done whenever the accounter fails."""
196        validactions = [ "CONTINUE", "STOP" ]     
197        try :
198            action = self.getPrinterOption(printername, "onaccountererror")
199        except PyKotaConfigError :   
200            return "STOP"
201        else :   
202            action = action.upper()
203            if action not in validactions :
204                raise PyKotaConfigError, _("Option onaccountererror in section %s only supports values in %s") % (printername, str(validactions))
205            return action 
206           
207    def getPrinterPolicy(self, printername) :   
208        """Returns the default policy for the current printer."""
209        validpolicies = [ "ALLOW", "DENY", "EXTERNAL" ]     
210        try :
211            fullpolicy = self.getPrinterOption(printername, "policy")
212        except PyKotaConfigError :   
213            return ("DENY", None)
214        else :   
215            try :
216                policy = [x.strip() for x in fullpolicy.split('(', 1)]
217            except ValueError :   
218                raise PyKotaConfigError, _("Invalid policy %s for printer %s") % (fullpolicy, printername)
219            if len(policy) == 1 :   
220                policy.append("")
221            (policy, args) = policy   
222            if args.endswith(')') :
223                args = args[:-1]
224            policy = policy.upper()   
225            if (policy == "EXTERNAL") and not args :
226                raise PyKotaConfigError, _("Invalid policy %s for printer %s") % (fullpolicy, printername)
227            if policy not in validpolicies :
228                raise PyKotaConfigError, _("Option policy in section %s only supports values in %s") % (printername, str(validpolicies))
229            return (policy, args)
230       
231    def getCrashRecipient(self) :   
232        """Returns the email address of the software crash messages recipient."""
233        try :
234            return self.getGlobalOption("crashrecipient")
235        except :   
236            return
237           
238    def getSMTPServer(self) :   
239        """Returns the SMTP server to use to send messages to users."""
240        try :
241            return self.getGlobalOption("smtpserver")
242        except PyKotaConfigError :   
243            return "localhost"
244       
245    def getMailDomain(self) :   
246        """Returns the mail domain to use to send messages to users."""
247        try :
248            return self.getGlobalOption("maildomain")
249        except PyKotaConfigError :   
250            return 
251       
252    def getAdminMail(self, printername) :   
253        """Returns the Email address of the Print Quota Administrator."""
254        try :
255            return self.getPrinterOption(printername, "adminmail")
256        except PyKotaConfigError :   
257            return "root@localhost"
258       
259    def getAdmin(self, printername) :   
260        """Returns the full name of the Print Quota Administrator."""
261        try :
262            return self.getPrinterOption(printername, "admin")
263        except PyKotaConfigError :   
264            return "root"
265       
266    def getMailTo(self, printername) :   
267        """Returns the recipient of email messages."""
268        validmailtos = [ "EXTERNAL", "NOBODY", "NONE", "NOONE", "BITBUCKET", "DEVNULL", "BOTH", "USER", "ADMIN" ]
269        try :
270            fullmailto = self.getPrinterOption(printername, "mailto")
271        except PyKotaConfigError :   
272            return ("BOTH", None)
273        else :   
274            try :
275                mailto = [x.strip() for x in fullmailto.split('(', 1)]
276            except ValueError :   
277                raise PyKotaConfigError, _("Invalid option mailto %s for printer %s") % (fullmailto, printername)
278            if len(mailto) == 1 :   
279                mailto.append("")
280            (mailto, args) = mailto   
281            if args.endswith(')') :
282                args = args[:-1]
283            mailto = mailto.upper()   
284            if (mailto == "EXTERNAL") and not args :
285                raise PyKotaConfigError, _("Invalid option mailto %s for printer %s") % (fullmailto, printername)
286            if mailto not in validmailtos :
287                raise PyKotaConfigError, _("Option mailto in section %s only supports values in %s") % (printername, str(validmailtos))
288            return (mailto, args)
289       
290    def getMaxDenyBanners(self, printername) :   
291        """Returns the maximum number of deny banners to be printed for a particular user on a particular printer."""
292        try :
293            maxdb = self.getPrinterOption(printername, "maxdenybanners")
294        except PyKotaConfigError :   
295            return 0 # default value is to forbid printing a deny banner.
296        try :
297            value = int(maxdb.strip())
298            if value < 0 :
299                raise ValueError
300        except (TypeError, ValueError) :   
301            raise PyKotaConfigError, _("Invalid maximal deny banners counter %s") % maxdb
302        else :   
303            return value
304           
305    def getGraceDelay(self, printername) :   
306        """Returns the grace delay in days."""
307        try :
308            gd = self.getPrinterOption(printername, "gracedelay")
309        except PyKotaConfigError :   
310            gd = 7      # default value of 7 days
311        try :
312            return int(gd)
313        except (TypeError, ValueError) :   
314            raise PyKotaConfigError, _("Invalid grace delay %s") % gd
315           
316    def getPoorMan(self) :   
317        """Returns the poor man's threshold."""
318        try :
319            pm = self.getGlobalOption("poorman")
320        except PyKotaConfigError :   
321            pm = 1.0    # default value of 1 unit
322        try :
323            return float(pm)
324        except (TypeError, ValueError) :   
325            raise PyKotaConfigError, _("Invalid poor man's threshold %s") % pm
326           
327    def getPoorWarn(self) :   
328        """Returns the poor man's warning message."""
329        try :
330            return self.getGlobalOption("poorwarn")
331        except PyKotaConfigError :   
332            return _("Your Print Quota account balance is Low.\nSoon you'll not be allowed to print anymore.\nPlease contact the Print Quota Administrator to solve the problem.")
333           
334    def getHardWarn(self, printername) :   
335        """Returns the hard limit error message."""
336        try :
337            return self.getPrinterOption(printername, "hardwarn")
338        except PyKotaConfigError :   
339            return _("You are not allowed to print anymore because\nyour Print Quota is exceeded on printer %s.") % printername
340           
341    def getSoftWarn(self, printername) :   
342        """Returns the soft limit error message."""
343        try :
344            return self.getPrinterOption(printername, "softwarn")
345        except PyKotaConfigError :   
346            return _("You will soon be forbidden to print anymore because\nyour Print Quota is almost reached on printer %s.") % printername
347           
348    def getPrivacy(self) :       
349        """Returns 1 if privacy is activated, else 0."""
350        return self.isTrue(self.getGlobalOption("privacy", ignore=1))
351       
352    def getDebug(self) :         
353        """Returns 1 if debugging is activated, else 0."""
354        return self.isTrue(self.getGlobalOption("debug", ignore=1))
355           
356    def getCaching(self) :         
357        """Returns 1 if database caching is enabled, else 0."""
358        return self.isTrue(self.getGlobalOption("storagecaching", ignore=1))
359           
360    def getLDAPCache(self) :         
361        """Returns 1 if low-level LDAP caching is enabled, else 0."""
362        return self.isTrue(self.getGlobalOption("ldapcache", ignore=1))
363           
364    def getDisableHistory(self) :         
365        """Returns 1 if we want to disable history, else 0."""
366        return self.isTrue(self.getGlobalOption("disablehistory", ignore=1))
367           
368    def getUserNameToLower(self) :         
369        """Returns 1 if we want to convert usernames to lowercase when printing, else 0."""
370        return self.isTrue(self.getGlobalOption("utolower", ignore=1))
371       
372    def getRejectUnknown(self) :         
373        """Returns 1 if we want to reject the creation of unknown users or groups, else 0."""
374        return self.isTrue(self.getGlobalOption("reject_unknown", ignore=1))
375       
376    def getDenyDuplicates(self, printername) :         
377        """Returns 1 if we want to deny duplicate jobs, else 0."""
378        try : 
379            return self.isTrue(self.getPrinterOption(printername, "denyduplicates"))
380        except PyKotaConfigError :   
381            return 0
382       
383    def getWinbindSeparator(self) :         
384        """Returns the winbind separator's value if it is set, else None."""
385        return self.getGlobalOption("winbind_separator", ignore=1)
386
387    def getAccountBanner(self, printername) :
388        """Returns which banner(s) to account for: NONE, BOTH, STARTING, ENDING."""
389        validvalues = [ "NONE", "BOTH", "STARTING", "ENDING" ]     
390        try :
391            value = self.getPrinterOption(printername, "accountbanner")
392        except PyKotaConfigError :   
393            return "BOTH"       # Default value of BOTH
394        else :   
395            value = value.strip().upper()
396            if value not in validvalues :
397                raise PyKotaConfigError, _("Option accountbanner in section %s only supports values in %s") % (printername, str(validvalues))
398            return value 
399
400    def getStartingBanner(self, printername) :
401        """Returns the startingbanner value if set, else None."""
402        try :
403            return self.getPrinterOption(printername, "startingbanner").strip()
404        except PyKotaConfigError :
405            return None
406
407    def getEndingBanner(self, printername) :
408        """Returns the endingbanner value if set, else None."""
409        try :
410            return self.getPrinterOption(printername, "endingbanner").strip()
411        except PyKotaConfigError :
412            return None
413           
414    def getTrustJobSize(self, printername) :
415        """Returns the normalized value of the trustjobsize's directive."""
416        try :
417            value = self.getPrinterOption(printername, "trustjobsize").strip().upper()
418        except PyKotaConfigError :
419            return (None, "YES")
420        else :   
421            if value == "YES" :
422                return (None, "YES")
423            try :   
424                (limit, replacement) = [p.strip() for p in value.split(">")[1].split(":")]
425                limit = int(limit)
426                try :
427                    replacement = int(replacement) 
428                except ValueError :   
429                    if replacement != "PRECOMPUTED" :
430                        raise
431                if limit < 0 :
432                    raise ValueError
433                if (replacement != "PRECOMPUTED") and (replacement < 0) :
434                    raise ValueError
435            except (IndexError, ValueError, TypeError) :
436                raise PyKotaConfigError, _("Option trustjobsize for printer %s is incorrect") % printername
437            return (limit, replacement)   
Note: See TracBrowser for help on using the browser.