root / tea4cups / trunk / tea4cups @ 627

Revision 627, 40.7 kB (checked in by jerome, 19 years ago)

Fix for Python 2.1

  • Property svn:executable set to *
  • Property svn:keywords set to Author Date Id Rev
Line 
1#! /usr/bin/env python
2# -*- coding: ISO-8859-15 -*-
3
4# Tea4CUPS : Tee for CUPS
5#
6# (c) 2005 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 sys
26import os
27import popen2
28import errno
29import md5
30import cStringIO
31import shlex
32import tempfile
33import ConfigParser
34import select
35import signal
36import time
37from struct import unpack
38
39version = "2.11_unofficial"
40
41class TeeError(Exception):
42    """Base exception for Tea4CUPS related stuff."""
43    def __init__(self, message = ""):
44        self.message = message
45        Exception.__init__(self, message)
46    def __repr__(self):
47        return self.message
48    __str__ = __repr__
49   
50class ConfigError(TeeError) :   
51    """Configuration related exceptions."""
52    pass 
53   
54class IPPError(TeeError) :   
55    """IPP related exceptions."""
56    pass 
57   
58class Popen4ForCUPS(popen2.Popen4) :
59    """Our own class to execute real backends.
60   
61       Their first argument is different from their path so using
62       native popen2.Popen3 would not be feasible.
63    """
64    def __init__(self, cmd, bufsize=-1, arg0=None) :
65        self.arg0 = arg0
66        popen2.Popen4.__init__(self, cmd, bufsize)
67       
68    def _run_child(self, cmd):
69        try :
70            MAXFD = os.sysconf("SC_OPEN_MAX")
71        except (AttributeError, ValueError) :   
72            MAXFD = 256
73        for i in range(3, MAXFD) : 
74            try:
75                os.close(i)
76            except OSError:
77                pass
78        try:
79            os.execvpe(cmd[0], [self.arg0 or cmd[0]] + cmd[1:], os.environ)
80        finally:
81            os._exit(1)
82   
83# Some IPP constants   
84OPERATION_ATTRIBUTES_TAG = 0x01
85JOB_ATTRIBUTES_TAG = 0x02
86END_OF_ATTRIBUTES_TAG = 0x03
87PRINTER_ATTRIBUTES_TAG = 0x04
88UNSUPPORTED_ATTRIBUTES_TAG = 0x05
89
90class IPPMessage :
91    """A class for IPP message files."""
92    def __init__(self, data) :
93        """Initializes an IPP Message object."""
94        self.data = data
95        self._attributes = {}
96        self.curname = None
97        self.tags = [ None ] * 256      # by default all tags reserved
98       
99        # Delimiter tags
100        self.tags[0x01] = "operation-attributes-tag"
101        self.tags[0x02] = "job-attributes-tag"
102        self.tags[0x03] = "end-of-attributes-tag"
103        self.tags[0x04] = "printer-attributes-tag"
104        self.tags[0x05] = "unsupported-attributes-tag"
105       
106        # out of band values
107        self.tags[0x10] = "unsupported"
108        self.tags[0x11] = "reserved-for-future-default"
109        self.tags[0x12] = "unknown"
110        self.tags[0x13] = "no-value"
111       
112        # integer values
113        self.tags[0x20] = "generic-integer"
114        self.tags[0x21] = "integer"
115        self.tags[0x22] = "boolean"
116        self.tags[0x23] = "enum"
117       
118        # octetString
119        self.tags[0x30] = "octetString-with-an-unspecified-format"
120        self.tags[0x31] = "dateTime"
121        self.tags[0x32] = "resolution"
122        self.tags[0x33] = "rangeOfInteger"
123        self.tags[0x34] = "reserved-for-collection"
124        self.tags[0x35] = "textWithLanguage"
125        self.tags[0x36] = "nameWithLanguage"
126       
127        # character strings
128        self.tags[0x20] = "generic-character-string"
129        self.tags[0x41] = "textWithoutLanguage"
130        self.tags[0x42] = "nameWithoutLanguage"
131        # self.tags[0x43] = "reserved"
132        self.tags[0x44] = "keyword"
133        self.tags[0x45] = "uri"
134        self.tags[0x46] = "uriScheme"
135        self.tags[0x47] = "charset"
136        self.tags[0x48] = "naturalLanguage"
137        self.tags[0x49] = "mimeMediaType"
138       
139        # now parses the IPP message
140        self.parse()
141       
142    def __getattr__(self, attrname) :   
143        """Allows self.attributes to return the attributes names."""
144        if attrname == "attributes" :
145            keys = self._attributes.keys()
146            keys.sort()
147            return keys
148        raise AttributeError, attrname
149           
150    def __getitem__(self, ippattrname) :   
151        """Fakes a dictionnary d['key'] notation."""
152        value = self._attributes.get(ippattrname)
153        if value is not None :
154            if len(value) == 1 :
155                value = value[0]
156        return value       
157    get = __getitem__   
158       
159    def parseTag(self) :   
160        """Extracts information from an IPP tag."""
161        pos = self.position
162        valuetag = self.tags[ord(self.data[pos])]
163        # print valuetag.get("name")
164        pos += 1
165        posend = pos2 = pos + 2
166        namelength = unpack(">H", self.data[pos:pos2])[0]
167        if not namelength :
168            name = self.curname
169        else :   
170            posend += namelength
171            self.curname = name = self.data[pos2:posend]
172        pos2 = posend + 2
173        valuelength = unpack(">H", self.data[posend:pos2])[0]
174        posend = pos2 + valuelength
175        value = self.data[pos2:posend]
176        oldval = self._attributes.setdefault(name, [])
177        oldval.append(value)
178        return posend - self.position
179       
180    def operation_attributes_tag(self) : 
181        """Indicates that the parser enters into an operation-attributes-tag group."""
182        return self.parseTag()
183       
184    def job_attributes_tag(self) : 
185        """Indicates that the parser enters into a job-attributes-tag group."""
186        return self.parseTag()
187       
188    def printer_attributes_tag(self) : 
189        """Indicates that the parser enters into a printer-attributes-tag group."""
190        return self.parseTag()
191       
192    def parse(self) :
193        """Parses an IPP Message.
194       
195           NB : Only a subset of RFC2910 is implemented.
196           We are only interested in textual informations for now anyway.
197        """
198        self.version = "%s.%s" % (ord(self.data[0]), ord(self.data[1]))
199        self.operation_id = "0x%04x" % unpack(">H", self.data[2:4])[0]
200        self.request_id = "0x%08x" % unpack(">I", self.data[4:8])[0]
201        self.position = 8
202        try :
203            tag = ord(self.data[self.position])
204            while tag != END_OF_ATTRIBUTES_TAG :
205                self.position += 1
206                name = self.tags[tag]
207                if name is not None :
208                    func = getattr(self, name.replace("-", "_"), None)
209                    if func is not None :
210                        self.position += func()
211                        if ord(self.data[self.position]) > UNSUPPORTED_ATTRIBUTES_TAG :
212                            self.position -= 1
213                            continue
214                tag = ord(self.data[self.position])
215        except IndexError :
216            raise IPPError, "Unexpected end of IPP message."
217           
218class FakeConfig :   
219    """Fakes a configuration file parser."""
220    def get(self, section, option, raw=0) :
221        """Fakes the retrieval of an option."""
222        raise ConfigError, "Invalid configuration file : no option %s in section [%s]" % (option, section)
223       
224class CupsBackend :
225    """Base class for tools with no database access."""
226    def __init__(self) :
227        """Initializes the CUPS backend wrapper."""
228        signal.signal(signal.SIGTERM, signal.SIG_IGN)
229        signal.signal(signal.SIGPIPE, signal.SIG_IGN)
230        self.MyName = "Tea4CUPS"
231        self.myname = "tea4cups"
232        self.pid = os.getpid()
233       
234    def readConfig(self) :   
235        """Reads the configuration file."""
236        confdir = os.environ.get("CUPS_SERVERROOT", ".") 
237        self.conffile = os.path.join(confdir, "%s.conf" % self.myname)
238        if os.path.isfile(self.conffile) :
239            self.config = ConfigParser.ConfigParser()
240            self.config.read([self.conffile])
241            self.debug = self.isTrue(self.getGlobalOption("debug", ignore=1))
242        else :   
243            self.config = FakeConfig()
244            self.debug = 1      # no config, so force debug mode !
245           
246    def logInfo(self, message, level="info") :       
247        """Logs a message to CUPS' error_log file."""
248        sys.stderr.write("%s: %s v%s (PID %i) : %s\n" % (level.upper(), self.MyName, version, os.getpid(), message))
249        sys.stderr.flush()
250       
251    def logDebug(self, message) :   
252        """Logs something to debug output if debug is enabled."""
253        if self.debug :
254            self.logInfo(message, level="debug")
255       
256    def isTrue(self, option) :       
257        """Returns 1 if option is set to true, else 0."""
258        if (option is not None) and (option.upper().strip() in ['Y', 'YES', '1', 'ON', 'T', 'TRUE']) :
259            return 1
260        else :   
261            return 0
262                       
263    def getGlobalOption(self, option, ignore=0) :   
264        """Returns an option from the global section, or raises a ConfigError if ignore is not set, else returns None."""
265        try :
266            return self.config.get("global", option, raw=1)
267        except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) :   
268            if not ignore :
269                raise ConfigError, "Option %s not found in section global of %s" % (option, self.conffile)
270               
271    def getPrintQueueOption(self, printqueuename, option, ignore=0) :   
272        """Returns an option from the printer section, or the global section, or raises a ConfigError."""
273        globaloption = self.getGlobalOption(option, ignore=1)
274        try :
275            return self.config.get(printqueuename, option, raw=1)
276        except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) :   
277            if globaloption is not None :
278                return globaloption
279            elif not ignore :
280                raise ConfigError, "Option %s not found in section [%s] of %s" % (option, printqueuename, self.conffile)
281               
282    def enumBranches(self, printqueuename, branchtype="tee") :
283        """Returns the list of branchtypes branches for a particular section's."""
284        branchbasename = "%s_" % branchtype.lower()
285        try :
286            # globalbranches = [ (k, v) for (k, v) in self.config.items("global") if k.startswith(branchbasename) ]
287            globalbranches = [ (k, self.config.get("global", k)) for k in self.config.options("global") if k.startswith(branchbasename) ]
288        except ConfigParser.NoSectionError, msg :   
289            raise ConfigError, "Invalid configuration file : %s" % msg
290        try :
291            # sectionbranches = [ (k, v) for (k, v) in self.config.items(printqueuename) if k.startswith(branchbasename) ]
292            sectionbranches = [ (k, self.config.get(printqueuename, k)) for k in self.config.options(printqueuename) if k.startswith(branchbasename) ]
293        except ConfigParser.NoSectionError, msg :   
294            self.logInfo("No section for print queue %s : %s" % (printqueuename, msg))
295            sectionbranches = []
296        branches = {}
297        for (k, v) in globalbranches :
298            value = v.strip()
299            if value :
300                branches[k] = value
301        for (k, v) in sectionbranches :   
302            value = v.strip()
303            if value :
304                branches[k] = value # overwrite any global option or set a new value
305            else :   
306                del branches[k] # empty value disables a global option
307        return branches
308       
309    def discoverOtherBackends(self) :   
310        """Discovers the other CUPS backends.
311       
312           Executes each existing backend in turn in device enumeration mode.
313           Returns the list of available backends.
314        """
315        # Unfortunately this method can't output any debug information
316        # to stdout or stderr, else CUPS considers that the device is
317        # not available.
318        available = []
319        (directory, myname) = os.path.split(sys.argv[0])
320        if not directory :
321            directory = "./"
322        tmpdir = tempfile.gettempdir()
323        lockfilename = os.path.join(tmpdir, "%s..LCK" % myname)
324        if os.path.exists(lockfilename) :
325            lockfile = open(lockfilename, "r")
326            pid = int(lockfile.read())
327            lockfile.close()
328            try :
329                # see if the pid contained in the lock file is still running
330                os.kill(pid, 0)
331            except OSError, e :   
332                if e.errno != errno.EPERM :
333                    # process doesn't exist anymore
334                    os.remove(lockfilename)
335           
336        if not os.path.exists(lockfilename) :
337            lockfile = open(lockfilename, "w")
338            lockfile.write("%i" % self.pid)
339            lockfile.close()
340            allbackends = [ os.path.join(directory, b) \
341                                for b in os.listdir(directory) 
342                                    if os.access(os.path.join(directory, b), os.X_OK) \
343                                        and (b != myname)] 
344            for backend in allbackends :                           
345                answer = os.popen(backend, "r")
346                try :
347                    devices = [line.strip() for line in answer.readlines()]
348                except :   
349                    devices = []
350                status = answer.close()
351                if status is None :
352                    for d in devices :
353                        # each line is of the form :
354                        # 'xxxx xxxx "xxxx xxx" "xxxx xxx"'
355                        # so we have to decompose it carefully
356                        fdevice = cStringIO.StringIO(d)
357                        tokenizer = shlex.shlex(fdevice)
358                        tokenizer.wordchars = tokenizer.wordchars + \
359                                                        r".:,?!~/\_$*-+={}[]()#"
360                        arguments = []
361                        while 1 :
362                            token = tokenizer.get_token()
363                            if token :
364                                arguments.append(token)
365                            else :
366                                break
367                        fdevice.close()
368                        try :
369                            (devicetype, device, name, fullname) = arguments
370                        except ValueError :   
371                            pass    # ignore this 'bizarre' device
372                        else :   
373                            if name.startswith('"') and name.endswith('"') :
374                                name = name[1:-1]
375                            if fullname.startswith('"') and fullname.endswith('"') :
376                                fullname = fullname[1:-1]
377                            available.append('%s %s:%s "%s+%s" "%s managed %s"' \
378                                                 % (devicetype, self.myname, device, self.MyName, name, self.MyName, fullname))
379            os.remove(lockfilename)
380        available.append('direct %s:// "%s+Nothing" "%s managed Virtual Printer"' \
381                             % (self.myname, self.MyName, self.MyName))
382        return available
383                       
384    def initBackend(self) :   
385        """Initializes the backend's attributes."""
386        # check that the DEVICE_URI environment variable's value is
387        # prefixed with self.myname otherwise don't touch it.
388        # If this is the case, we have to remove the prefix from
389        # the environment before launching the real backend
390        muststartwith = "%s:" % self.myname
391        device_uri = os.environ.get("DEVICE_URI", "")
392        if device_uri.startswith(muststartwith) :
393            fulldevice_uri = device_uri[:]
394            device_uri = fulldevice_uri[len(muststartwith):]
395            for i in range(2) :
396                if device_uri.startswith("/") : 
397                    device_uri = device_uri[1:]
398        try :
399            (backend, destination) = device_uri.split(":", 1) 
400        except ValueError :   
401            if not device_uri :
402                self.logDebug("Not attached to an existing print queue.")
403                backend = ""
404            else :   
405                raise TeeError, "Invalid DEVICE_URI : %s\n" % device_uri
406       
407        self.JobId = sys.argv[1].strip()
408        self.UserName = sys.argv[2].strip()
409        self.Title = sys.argv[3].strip()
410        self.Copies = int(sys.argv[4].strip())
411        self.Options = sys.argv[5].strip()
412        if len(sys.argv) == 7 :
413            self.InputFile = sys.argv[6] # read job's datas from file
414        else :   
415            self.InputFile = None        # read job's datas from stdin
416           
417        self.RealBackend = backend
418        self.DeviceURI = device_uri
419        self.PrinterName = os.environ.get("PRINTER", "")
420        self.Directory = self.getPrintQueueOption(self.PrinterName, "directory")
421        self.DataFile = os.path.join(self.Directory, "%s-%s-%s-%s" % (self.myname, self.PrinterName, self.UserName, self.JobId))
422        (ippfilename, ippmessage) = self.parseIPPMessageFile()
423        self.ControlFile = ippfilename
424        self.ClientHost = ippmessage.get("job-originating-host-name")
425        self.JobBilling = ippmessage.get("job-billing")
426           
427    def getCupsConfigDirectives(self, directives=[]) :
428        """Retrieves some CUPS directives from its configuration file.
429       
430           Returns a mapping with lowercased directives as keys and
431           their setting as values.
432        """
433        dirvalues = {} 
434        cupsroot = os.environ.get("CUPS_SERVERROOT", "/etc/cups")
435        cupsdconf = os.path.join(cupsroot, "cupsd.conf")
436        try :
437            conffile = open(cupsdconf, "r")
438        except IOError :   
439            raise TeeError, "Unable to open %s" % cupsdconf
440        else :   
441            for line in conffile.readlines() :
442                linecopy = line.strip().lower()
443                for di in [d.lower() for d in directives] :
444                    if linecopy.startswith("%s " % di) :
445                        try :
446                            val = line.split()[1]
447                        except :   
448                            pass # ignore errors, we take the last value in any case.
449                        else :   
450                            dirvalues[di] = val
451            conffile.close()           
452        return dirvalues       
453           
454    def parseIPPMessageFile(self) :       
455        """Parses the IPP message file and returns a tuple (filename, parsedvalue)."""
456        cupsdconf = self.getCupsConfigDirectives(["RequestRoot"])
457        requestroot = cupsdconf.get("requestroot", "/var/spool/cups")
458        if (len(self.JobId) < 5) and self.JobId.isdigit() :
459            ippmessagefile = "c%05i" % int(self.JobId)
460        else :   
461            ippmessagefile = "c%s" % self.JobId
462        ippmessagefile = os.path.join(requestroot, ippmessagefile)
463        ippmessage = {}
464        try :
465            ippdatafile = open(ippmessagefile)
466        except :   
467            self.logInfo("Unable to open IPP message file %s" % ippmessagefile, "warn")
468        else :   
469            self.logDebug("Parsing of IPP message file %s begins." % ippmessagefile)
470            try :
471                ippmessage = IPPMessage(ippdatafile.read())
472            except IPPError, msg :   
473                self.logInfo("Error while parsing %s : %s" % (ippmessagefile, msg), "warn")
474            else :   
475                self.logDebug("Parsing of IPP message file %s ends." % ippmessagefile)
476            ippdatafile.close()
477        return (ippmessagefile, ippmessage)
478               
479    def exportAttributes(self) :   
480        """Exports our backend's attributes to the environment."""
481        os.environ["DEVICE_URI"] = self.DeviceURI       # WARNING !
482        os.environ["TEAPRINTERNAME"] = self.PrinterName
483        os.environ["TEADIRECTORY"] = self.Directory
484        os.environ["TEADATAFILE"] = self.DataFile
485        os.environ["TEAJOBSIZE"] = str(self.JobSize)
486        os.environ["TEAMD5SUM"] = self.JobMD5Sum
487        os.environ["TEACLIENTHOST"] = self.ClientHost or ""
488        os.environ["TEAJOBID"] = self.JobId
489        os.environ["TEAUSERNAME"] = self.UserName
490        os.environ["TEATITLE"] = self.Title
491        os.environ["TEACOPIES"] = str(self.Copies)
492        os.environ["TEAOPTIONS"] = self.Options
493        os.environ["TEAINPUTFILE"] = self.InputFile or ""
494        os.environ["TEABILLING"] = self.JobBilling or ""
495        os.environ["TEACONTROLFILE"] = self.ControlFile
496       
497    def saveDatasAndCheckSum(self) :
498        """Saves the input datas into a static file."""
499        self.logDebug("Duplicating data stream into %s" % self.DataFile)
500        mustclose = 0
501        if self.InputFile is not None :
502            infile = open(self.InputFile, "rb")
503            mustclose = 1
504        else :   
505            infile = sys.stdin
506        CHUNK = 64*1024         # read 64 Kb at a time
507        dummy = 0
508        sizeread = 0
509        checksum = md5.new()
510        outfile = open(self.DataFile, "wb")   
511        while 1 :
512            data = infile.read(CHUNK) 
513            if not data :
514                break
515            sizeread += len(data)   
516            outfile.write(data)
517            checksum.update(data)   
518            if not (dummy % 32) : # Only display every 2 Mb
519                self.logDebug("%s bytes saved..." % sizeread)
520            dummy += 1   
521        outfile.close()
522        if mustclose :   
523            infile.close()
524        self.JobSize = sizeread   
525        self.JobMD5Sum = checksum.hexdigest()
526        self.logDebug("Job %s is %s bytes long." % (self.JobId, self.JobSize))
527        self.logDebug("Job %s MD5 sum is %s" % (self.JobId, self.JobMD5Sum))
528
529    def cleanUp(self) :
530        """Cleans up the place."""
531        if not self.isTrue(self.getPrintQueueOption(self.PrinterName, "keepfiles", ignore=1)) :
532            os.remove(self.DataFile)
533           
534    def sigtermHandler(self, signum, frame) :
535        """Sets an attribute whenever SIGTERM is received."""
536        self.gotSigTerm = 1
537        self.logInfo("SIGTERM received for Job %s." % self.JobId)
538       
539    def runBranches(self) :         
540        """Launches each hook or tee defined for the current print queue."""
541        exitcode = 0
542        self.isCancelled = 0    # did a prehook cancel the print job ?
543        self.gotSigTerm = 0
544        signal.signal(signal.SIGTERM, self.sigtermHandler)
545        serialize = self.isTrue(self.getPrintQueueOption(self.PrinterName, "serialize", ignore=1))
546        for branchtype in ["prehook", "tee", "posthook"] :
547            branches = self.enumBranches(self.PrinterName, branchtype)
548            status = self.runCommands(branchtype, branches, serialize)
549            if status :
550                if branchtype != "posthook" :
551                    exitcode = status
552                else :   
553                    # we just ignore error in posthooks
554                    self.logInfo("An error occured during the execution of posthooks.", "warn")
555            if (branchtype == "prehook") and self.isCancelled :
556                break # We don't want to execute tees or posthooks in this case
557        signal.signal(signal.SIGTERM, signal.SIG_IGN)
558        if not exitcode :
559            self.logInfo("OK")
560        else :   
561            self.logInfo("An error occured, please check CUPS' error_log file.")
562        return exitcode
563       
564    def runCommands(self, btype, branches, serialize) :   
565        """Runs the commands for a particular branch type."""
566        exitcode = 0 
567        btype = btype.lower()
568        btypetitle = btype.title()
569        branchlist = branches.keys()   
570        branchlist.sort()
571        if serialize :
572            self.logDebug("Begin serialized %ss" % btypetitle)
573            if (btype == "tee") and self.RealBackend :
574                self.logDebug("Launching original backend %s for printer %s" % (self.RealBackend, self.PrinterName))
575                retcode = self.runOriginalBackend()
576                if os.WIFEXITED(retcode) :
577                    retcode = os.WEXITSTATUS(retcode)
578                os.environ["TEASTATUS"] = str(retcode)
579                exitcode = retcode
580            for branch in branchlist :
581                command = branches[branch]
582                if self.gotSigTerm :
583                    break
584                self.logDebug("Launching %s : %s" % (branch, command))
585                retcode = os.system(command)
586                self.logDebug("Exit code for %s %s on printer %s is %s" % (btype, branch, self.PrinterName, retcode))
587                if os.WIFEXITED(retcode) :
588                    retcode = os.WEXITSTATUS(retcode)
589                if retcode :   
590                    if (btype == "prehook") and (retcode == 255) : # -1
591                        self.logInfo("Job %s cancelled by prehook %s" % (self.JobId, branch))
592                        self.isCancelled = 1
593                    else :   
594                        self.logInfo("%s %s on printer %s didn't exit successfully." % (btypetitle, branch, self.PrinterName), "error")
595                        exitcode = 1
596            self.logDebug("End serialized %ss" % btypetitle)
597        else :       
598            self.logDebug("Begin forked %ss" % btypetitle)
599            pids = {}
600            if (btype == "tee") and self.RealBackend :
601                branches["Original backend"] = None     # Fakes a tee to launch one more child
602                branchlist = ["Original backend"] + branchlist
603            for branch in branchlist :
604                command = branches[branch]
605                if self.gotSigTerm :
606                    break
607                pid = os.fork()
608                if pid :
609                    pids[branch] = pid
610                else :   
611                    if branch == "Original backend" :
612                        self.logDebug("Launching original backend %s for printer %s" % (self.RealBackend, self.PrinterName))
613                        sys.exit(self.runOriginalBackend())
614                    else :
615                        self.logDebug("Launching %s : %s" % (branch, command))
616                        retcode = os.system(command)
617                        if os.WIFEXITED(retcode) :
618                            retcode = os.WEXITSTATUS(retcode)
619                        else :   
620                            retcode = -1
621                        sys.exit(retcode)
622            for (branch, pid) in pids.items() :
623                (childpid, retcode) = os.waitpid(pid, 0)
624                self.logDebug("Exit code for %s %s (PID %s) on printer %s is %s" % (btype, branch, childpid, self.PrinterName, retcode))
625                if os.WIFEXITED(retcode) :
626                    retcode = os.WEXITSTATUS(retcode)
627                if retcode :   
628                    if (btype == "prehook") and (retcode == 255) : # -1
629                        self.logInfo("Job %s cancelled by prehook %s" % (self.JobId, branch))
630                        self.isCancelled = 1
631                    else :   
632                        self.logInfo("%s %s (PID %s) on printer %s didn't exit successfully." % (btypetitle, branch, childpid, self.PrinterName), "error")
633                        exitcode = 1
634                if branch == "Original backend" :   
635                    os.environ["TEASTATUS"] = str(retcode)
636            self.logDebug("End forked %ss" % btypetitle)
637        return exitcode
638       
639    def unregisterFileNo(self, pollobj, fileno) :               
640        """Removes a file handle from the polling object."""
641        try :
642            pollobj.unregister(fileno)
643        except KeyError :   
644            self.logInfo("File number %s unregistered twice from polling object, ignored." % fileno, "warn")
645        except :   
646            self.logDebug("Error while unregistering file number %s from polling object." % fileno)
647        else :   
648            self.logDebug("File number %s unregistered from polling object." % fileno)
649           
650    def formatFileEvent(self, fd, mask) :       
651        """Formats file debug info."""
652        maskval = []
653        if mask & select.POLLIN :
654            maskval.append("POLLIN")
655        if mask & select.POLLOUT :
656            maskval.append("POLLOUT")
657        if mask & select.POLLPRI :
658            maskval.append("POLLPRI")
659        if mask & select.POLLERR :
660            maskval.append("POLLERR")
661        if mask & select.POLLHUP :
662            maskval.append("POLLHUP")
663        if mask & select.POLLNVAL :
664            maskval.append("POLLNVAL")
665        return "%s (%s)" % (fd, " | ".join(maskval))
666       
667    def runOriginalBackend(self) :   
668        """Launches the original backend."""
669        originalbackend = os.path.join(os.path.split(sys.argv[0])[0], self.RealBackend)
670        arguments = sys.argv
671        self.logDebug("Starting original backend %s with args %s" % (originalbackend, " ".join(['"%s"' % a for a in ([os.environ["DEVICE_URI"]] + arguments[1:])])))
672        subprocess = Popen4ForCUPS([originalbackend] + arguments[1:], bufsize=0, arg0=os.environ["DEVICE_URI"])
673       
674        # Save file descriptors, we will need them later.
675        stderrfno = sys.stderr.fileno()
676        fromcfno = subprocess.fromchild.fileno()
677        tocfno = subprocess.tochild.fileno()
678       
679        # We will have to be careful when dealing with I/O
680        # So we use a poll object to know when to read or write
681        pollster = select.poll()
682        pollster.register(fromcfno, select.POLLIN | select.POLLPRI)
683        pollster.register(stderrfno, select.POLLOUT)
684        pollster.register(tocfno, select.POLLOUT)
685       
686        # Initialize our buffers
687        indata = ""
688        outdata = ""
689        endinput = endoutput = 0
690        inputclosed = outputclosed = 0
691        totaltochild = totalfromcups = 0
692        totalfromchild = totaltocups = 0
693       
694        if self.InputFile is None :
695           # this is not a real file, we read the job's data
696            # from our temporary file which is a copy of stdin
697            inf = open(self.DataFile, "rb")
698            infno = inf.fileno()
699            pollster.register(infno, select.POLLIN | select.POLLPRI)
700        else :   
701            # job's data is in a file, no need to pass the data
702            # to the original backend
703            self.logDebug("Job's data is in %s" % self.InputFile)
704            infno = None
705            endinput = 1
706       
707        self.logDebug("Entering streams polling loop...")
708        MEGABYTE = 1024*1024
709        killed = 0
710        status = -1
711        while (status == -1) and (not killed) and not (inputclosed and outputclosed) :
712            # First check if original backend is still alive
713            status = subprocess.poll()
714           
715            # Now if we got SIGTERM, we have
716            # to kill -TERM the original backend
717            if self.gotSigTerm and not killed :
718                try :
719                    os.kill(subprocess.pid, signal.SIGTERM)
720                except OSError, msg : # ignore but logs if process was already killed.
721                    self.logDebug("Error while sending signal to pid %s : %s" % (subprocess.pid, msg))
722                else :   
723                    self.logInfo(_("SIGTERM was sent to original backend %s (PID %s)") % (originalbackend, subprocess.pid))
724                    killed = 1
725           
726            # In any case, deal with any remaining I/O
727            try :
728                availablefds = pollster.poll(5000)
729            except select.error, msg :   
730                self.logDebug("Interrupted poll : %s" % msg)
731                availablefds = []
732            if not availablefds :
733                self.logDebug("Nothing to do, sleeping a bit...")
734                time.sleep(0.01) # give some time to the system
735            else :
736                for (fd, mask) in availablefds :
737                    try :
738                        if mask & select.POLLOUT :
739                            # We can write
740                            if fd == tocfno :
741                                if indata :
742                                    try :
743                                        nbwritten = os.write(fd, indata)   
744                                    except (OSError, IOError), msg :   
745                                        self.logDebug("Error while writing to original backend's stdin %s : %s" % (fd, msg))
746                                    else :   
747                                        if len(indata) != nbwritten :
748                                            self.logDebug("Short write to original backend's input !")
749                                        totaltochild += nbwritten   
750                                        self.logDebug("%s bytes sent to original backend so far..." % totaltochild)
751                                        indata = indata[nbwritten:]
752                                else :       
753                                    self.logDebug("No data to send to original backend yet, sleeping a bit...")
754                                    time.sleep(0.01)
755                                   
756                                if endinput :   
757                                    self.unregisterFileNo(pollster, tocfno)       
758                                    self.logDebug("Closing original backend's stdin.")
759                                    os.close(tocfno)
760                                    inputclosed = 1
761                            elif fd == stderrfno :
762                                if outdata :
763                                    try :
764                                        nbwritten = os.write(fd, outdata)
765                                    except (OSError, IOError), msg :   
766                                        self.logDebug("Error while writing to CUPS back channel (stderr) %s : %s" % (fd, msg))
767                                    else :
768                                        if len(outdata) != nbwritten :
769                                            self.logDebug("Short write to stderr (CUPS) !")
770                                        totaltocups += nbwritten   
771                                        self.logDebug("%s bytes sent back to CUPS so far..." % totaltocups)
772                                        outdata = outdata[nbwritten:]
773                                else :       
774                                    # self.logDebug("No data to send back to CUPS yet, sleeping a bit...") # Uncommenting this fills your logs
775                                    time.sleep(0.01) # Give some time to the system, stderr is ALWAYS writeable it seems.
776                                   
777                                if endoutput :   
778                                    self.unregisterFileNo(pollster, stderrfno)       
779                                    outputclosed = 1
780                            else :   
781                                self.logDebug("Unexpected : %s - Sleeping a bit..." % self.formatFileEvent(fd, mask))
782                                time.sleep(0.01)
783                               
784                        if mask & (select.POLLIN | select.POLLPRI) :     
785                            # We have something to read
786                            try :
787                                data = os.read(fd, MEGABYTE)
788                            except (IOError, OSError), msg :   
789                                self.logDebug("Error while reading file %s : %s" % (fd, msg))
790                            else :
791                                if fd == infno :
792                                    if not data :    # If yes, then no more input data
793                                        self.unregisterFileNo(pollster, infno)
794                                        self.logDebug("Input data ends.")
795                                        endinput = 1 # this happens with real files.
796                                    else :   
797                                        indata += data
798                                        totalfromcups += len(data)
799                                        self.logDebug("%s bytes read from CUPS so far..." % totalfromcups)
800                                elif fd == fromcfno :
801                                    if not data :
802                                        self.logDebug("No back channel data to read from original backend yet, sleeping a bit...")
803                                        time.sleep(0.01)
804                                    else :
805                                        outdata += data
806                                        totalfromchild += len(data)
807                                        self.logDebug("%s bytes read from original backend so far..." % totalfromchild)
808                                else :   
809                                    self.logDebug("Unexpected : %s - Sleeping a bit..." % self.formatFileEvent(fd, mask))
810                                    time.sleep(0.01)
811                                   
812                        if mask & (select.POLLHUP | select.POLLERR) :
813                            # Treat POLLERR as an EOF.
814                            # Some standard I/O stream has no more datas
815                            self.unregisterFileNo(pollster, fd)
816                            if fd == infno :
817                                # Here we are in the case where the input file is stdin.
818                                # which has no more data to be read.
819                                self.logDebug("Input data ends.")
820                                endinput = 1
821                            elif fd == fromcfno :   
822                                # We are no more interested in this file descriptor       
823                                self.logDebug("Closing original backend's stdout+stderr.")
824                                os.close(fromcfno)
825                                endoutput = 1
826                            else :   
827                                self.logDebug("Unexpected : %s - Sleeping a bit..." % self.formatFileEvent(fd, mask))
828                                time.sleep(0.01)
829                               
830                        if mask & select.POLLNVAL :       
831                            self.logDebug("File %s was closed. Unregistering from polling object." % fd)
832                            self.unregisterFileNo(pollster, fd)
833                    except IOError, msg :           
834                        self.logDebug("Got an IOError : %s" % msg) # we got signalled during an I/O
835               
836        # We must close the original backend's input stream
837        if killed and not inputclosed :
838            self.logDebug("Forcing close of original backend's stdin.")
839            os.close(tocfno)
840       
841        self.logDebug("Exiting streams polling loop...")
842       
843        self.logDebug("input data's final length : %s" % len(indata))
844        self.logDebug("back-channel data's final length : %s" % len(outdata))
845       
846        self.logDebug("Total bytes read from CUPS (job's datas) : %s" % totalfromcups)
847        self.logDebug("Total bytes sent to original backend (job's datas) : %s" % totaltochild)
848       
849        self.logDebug("Total bytes read from original backend (back-channel datas) : %s" % totalfromchild)
850        self.logDebug("Total bytes sent back to CUPS (back-channel datas) : %s" % totaltocups)
851       
852        # Check exit code of original CUPS backend.   
853        if status == -1 :
854            # we exited the loop before the original backend exited
855            # now we have to wait for it to finish and get its status
856            self.logDebug("Waiting for original backend to exit...")
857            try :
858                status = subprocess.wait()
859            except OSError : # already dead : TODO : detect when abnormal
860                status = 0
861        if os.WIFEXITED(status) :
862            return os.WEXITSTATUS(status)
863        elif not killed :   
864            self.logInfo("CUPS backend %s died abnormally." % originalbackend, "error")
865            return -1
866        else :   
867            return 1
868       
869if __name__ == "__main__" :   
870    # This is a CUPS backend, we should act and die like a CUPS backend
871    wrapper = CupsBackend()
872    if len(sys.argv) == 1 :
873        print "\n".join(wrapper.discoverOtherBackends())
874        sys.exit(0)               
875    elif len(sys.argv) not in (6, 7) :   
876        sys.stderr.write("ERROR: %s job-id user title copies options [file]\n"\
877                              % sys.argv[0])
878        sys.exit(1)
879    else :   
880        try :
881            wrapper.readConfig()
882            wrapper.initBackend()
883            wrapper.saveDatasAndCheckSum()
884            wrapper.exportAttributes()
885            retcode = wrapper.runBranches()
886            wrapper.cleanUp()
887        except SystemExit, e :   
888            retcode = e.code
889        except :   
890            import traceback
891            lines = []
892            for line in traceback.format_exception(*sys.exc_info()) :
893                lines.extend([l for l in line.split("\n") if l])
894            msg = "ERROR: ".join(["%s (PID %s) : %s\n" % (wrapper.MyName, wrapper.pid, l) for l in (["ERROR: Tea4CUPS v%s" % version] + lines)])
895            sys.stderr.write(msg)
896            sys.stderr.flush()
897            retcode = 1
898        sys.exit(retcode)
Note: See TracBrowser for help on using the browser.