Show
Ignore:
Timestamp:
09/27/08 22:02:37 (16 years ago)
Author:
jerome
Message:

Removed unnecessary spaces at EOL.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • pykota/trunk/bin/pkturnkey

    r3411 r3413  
    99# the Free Software Foundation, either version 3 of the License, or 
    1010# (at your option) any later version. 
    11 #  
     11# 
    1212# This program is distributed in the hope that it will be useful, 
    1313# but WITHOUT ANY WARRANTY; without even the implied warranty of 
    1414# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1515# GNU General Public License for more details. 
    16 #  
     16# 
    1717# You should have received a copy of the GNU General Public License 
    1818# along with this program.  If not, see <http://www.gnu.org/licenses/>. 
    … …  
    5151  -v | --version       Prints pkturnkey version number then exits. 
    5252  -h | --help          Prints this message then exits. 
    53    
     53 
    5454  -c | --doconf        Give hints about what to put into pykota.conf 
    55    
     55 
    5656  -d | --dousers       Manages users accounts as well. 
    57    
     57 
    5858  -D | --dogroups      Manages users groups as well. 
    5959                       Implies -d | --dousers. 
    60    
     60 
    6161  -e | --emptygroups   Includes empty groups. 
    62    
     62 
    6363  -f | --force         Modifies the database instead of printing what 
    6464                       it would do. 
    65                         
     65 
    6666  -u | --uidmin uid    Only adds users whose uid is greater than or equal to 
    6767                       uid. You can pass an username there as well, and its 
    … …  
    6969                       If not set, 0 will be used automatically. 
    7070                       Implies -d | --dousers. 
    71                         
     71 
    7272  -U | --uidmax uid    Only adds users whose uid is lesser than or equal to 
    7373                       uid. You can pass an username there as well, and its 
    … …  
    8181                       If not set, 0 will be used automatically. 
    8282                       Implies -D | --dogroups. 
    83                         
     83 
    8484  -G | --gidmax gid    Only adds groups whose gid is lesser than or equal to 
    8585                       gid. You can pass a groupname there as well, and its 
    … …  
    8888                       Implies -D | --dogroups. 
    8989 
    90 examples :                               
     90examples : 
    9191 
    9292  $ pkturnkey --dousers --uidmin jerome 
    … …  
    9595  printers and print accounts for all users whose uid is greater than 
    9696  or equal to jerome's one. Won't manage any users group. 
    97    
     97 
    9898  To REALLY initialize the database instead of simulating it, please 
    9999  use the -f | --force command line switch. 
    100    
     100 
    101101  You can limit the initialization to only a subset of the existing 
    102102  printers, by passing their names at the end of the command line. 
    103103""") 
    104          
     104 
    105105class PKTurnKey(Tool) : 
    106106    """A class for an initialization tool.""" 
    … …  
    118118            if self.matchString(queuename, namestomatch) : 
    119119                printers.append((queuename, deviceuri)) 
    120             else :     
     120            else : 
    121121                self.printInfo("Print queue %s skipped." % queuename) 
    122         return printers     
    123          
    124     def listUsers(self, uidmin, uidmax) :     
     122        return printers 
     123 
     124    def listUsers(self, uidmin, uidmax) : 
    125125        """Returns a list of users whose uids are between uidmin and uidmax.""" 
    126126        self.printInfo("Extracting all users whose uid is between %s and %s." % (uidmin, uidmax)) 
    127127        return [(entry[0], entry[3]) for entry in pwd.getpwall() if uidmin <= entry[2] <= uidmax] 
    128          
     128 
    129129    def listGroups(self, gidmin, gidmax, users) : 
    130130        """Returns a list of groups whose gids are between gidmin and gidmax.""" 
    … …  
    135135        for u in users : 
    136136            gidusers.setdefault(u[1], []).append(u[0]) 
    137             usersgid.setdefault(u[0], []).append(u[1])  
    138              
    139         membership = {}     
     137            usersgid.setdefault(u[0], []).append(u[1]) 
     138 
     139        membership = {} 
    140140        for g in range(len(groups)) : 
    141141            (gname, gid, members) = groups[g] 
    … …  
    145145            try : 
    146146                usernames = gidusers[gid] 
    147             except KeyError :     
     147            except KeyError : 
    148148                pass 
    149             else :     
     149            else : 
    150150                for username in usernames : 
    151151                    if not newmembers.has_key(username) : 
    152152                        newmembers[username] = username 
    153             for member in newmembers.keys() :             
     153            for member in newmembers.keys() : 
    154154                if not usersgid.has_key(member) : 
    155155                    del newmembers[member] 
    156156            membership[gname] = newmembers.keys() 
    157157        return membership 
    158          
    159     def runCommand(self, command, dryrun) :     
     158 
     159    def runCommand(self, command, dryrun) : 
    160160        """Launches an external command.""" 
    161161        self.printInfo("%s" % command) 
    162         if not dryrun :     
     162        if not dryrun : 
    163163            os.system(command) 
    164              
    165     def createPrinters(self, printers, dryrun=0) :     
     164 
     165    def createPrinters(self, printers, dryrun=0) : 
    166166        """Creates all printers in PyKota's database.""" 
    167167        if printers : 
    … …  
    171171            args.close() 
    172172            self.runCommand("pkprinters --arguments /tmp/pkprinters.args", dryrun) 
    173          
     173 
    174174    def createUsers(self, users, printers, dryrun=0) : 
    175175        """Creates all users in PyKota's database.""" 
    … …  
    180180            args.close() 
    181181            self.runCommand("pkusers --arguments /tmp/pkusers.users.args", dryrun) 
    182              
     182 
    183183            printersnames = [p[0] for p in printers] 
    184184            args = open("/tmp/edpykota.users.args", "w") 
    … …  
    188188            args.close() 
    189189            self.runCommand("edpykota --arguments /tmp/edpykota.users.args", dryrun) 
    190              
     190 
    191191    def createGroups(self, groups, printers, dryrun=0) : 
    192192        """Creates all groups in PyKota's database.""" 
    … …  
    197197            args.close() 
    198198            self.runCommand("pkusers --arguments /tmp/pkusers.groups.args", dryrun) 
    199              
     199 
    200200            printersnames = [p[0] for p in printers] 
    201201            args = open("/tmp/edpykota.groups.args", "w") 
    … …  
    205205            args.close() 
    206206            self.runCommand("edpykota --arguments /tmp/edpykota.groups.args", dryrun) 
    207              
     207 
    208208            revmembership = {} 
    209209            for (groupname, usernames) in groups.items() : 
    210210                for username in usernames : 
    211211                    revmembership.setdefault(username, []).append(groupname) 
    212             commands = []         
    213             for (username, groupnames) in revmembership.items() :         
     212            commands = [] 
     213            for (username, groupnames) in revmembership.items() : 
    214214                commands.append('pkusers --ingroups %s "%s"' \ 
    215215                    % (",".join(['"%s"' % g for g in groupnames]), username)) 
    216216            for command in commands : 
    217217                self.runCommand(command, dryrun) 
    218          
     218 
    219219    def supportsSNMP(self, hostname, community) : 
    220220        """Returns 1 if the printer accepts SNMP queries, else 0.""" 
    … …  
    222222        try : 
    223223            from pysnmp.entity.rfc3413.oneliner import cmdgen 
    224         except ImportError :     
     224        except ImportError : 
    225225            hasV4 = False 
    226226            try : 
    … …  
    228228                from pysnmp.mapping.udp.role import Manager 
    229229                from pysnmp.proto.api import alpha 
    230             except ImportError :     
     230            except ImportError : 
    231231                logerr("pysnmp doesn't seem to be installed. SNMP checks will be ignored !\n") 
    232232                return 0 
    233         else :         
     233        else : 
    234234            hasV4 = True 
    235              
    236         if hasV4 :     
     235 
     236        if hasV4 : 
    237237            def retrieveSNMPValues(hostname, community) : 
    238238                """Retrieves a printer's internal page counter and status via SNMP.""" 
    … …  
    241241                                                      cmdgen.UdpTransportTarget((hostname, 161)), \ 
    242242                                                      tuple([int(i) for i in pageCounterOID.split('.')])) 
    243                 if errorIndication :                                                   
     243                if errorIndication : 
    244244                    raise "No SNMP !" 
    245                 elif errorStatus :     
     245                elif errorStatus : 
    246246                    raise "No SNMP !" 
    247                 else :                                  
     247                else : 
    248248                    self.SNMPOK = True 
    249249        else : 
    250             def retrieveSNMPValues(hostname, community) :     
     250            def retrieveSNMPValues(hostname, community) : 
    251251                """Retrieves a printer's internal page counter and status via SNMP.""" 
    252252                ver = alpha.protoVersions[alpha.protoVersionId1] 
    … …  
    260260                                       (hostname, 161), \ 
    261261                                       (handleAnswer, req)) 
    262                 except :     
     262                except : 
    263263                    raise "No SNMP !" 
    264264                tsp.close() 
    265              
     265 
    266266            def handleAnswer(wholemsg, notusedhere, req): 
    267267                """Decodes and handles the SNMP answer.""" 
    … …  
    270270                try : 
    271271                    rsp.berDecode(wholemsg) 
    272                 except TypeMismatchError, msg :     
     272                except TypeMismatchError, msg : 
    273273                    raise "No SNMP !" 
    274274                else : 
    … …  
    281281                            for varBind in rsp.apiAlphaGetPdu().apiAlphaGetVarBindList(): 
    282282                                self.values.append(varBind.apiAlphaGetOidVal()[1].rawAsn1Value) 
    283                             try :     
     283                            try : 
    284284                                pagecounter = self.values[0] 
    285285                            except : 
    286286                                raise "No SNMP !" 
    287                             else :     
     287                            else : 
    288288                                self.SNMPOK = 1 
    289289                                return 1 
    290              
     290 
    291291        self.SNMPOK = 0 
    292292        try : 
    293293            retrieveSNMPValues(hostname, community) 
    294         except :     
     294        except : 
    295295            self.SNMPOK = 0 
    296296        return self.SNMPOK 
    297          
     297 
    298298    def supportsPJL(self, hostname, port) : 
    299299        """Returns 1 if the printer accepts PJL queries over TCP, else 0.""" 
    300300        def alarmHandler(signum, frame) : 
    301301            raise "Timeout !" 
    302          
     302 
    303303        pjlsupport = 0 
    304304        signal.signal(signal.SIGALRM, alarmHandler) 
    … …  
    311311            if not answer.startswith("@PJL") : 
    312312                raise "No PJL !" 
    313         except :     
     313        except : 
    314314            pass 
    315         else :     
     315        else : 
    316316            pjlsupport = 1 
    317317        s.close() 
    … …  
    319319        signal.signal(signal.SIGALRM, signal.SIG_IGN) 
    320320        return pjlsupport 
    321              
    322     def hintConfig(self, printers) :     
     321 
     322    def hintConfig(self, printers) : 
    323323        """Gives some hints about what to put into pykota.conf""" 
    324324        if not printers : 
    325325            return 
    326         sys.stderr.flush() # ensure outputs don't mix     
    327         print      
     326        sys.stderr.flush() # ensure outputs don't mix 
     327        print 
    328328        print "--- CUT ---" 
    329329        print "# Here are some lines that we suggest you add at the end" 
    … …  
    338338            try : 
    339339                uri = uri.split("cupspykota:", 2)[-1] 
    340             except (ValueError, IndexError) :     
     340            except (ValueError, IndexError) : 
    341341                pass 
    342             else :     
     342            else : 
    343343                while uri and uri.startswith("/") : 
    344344                    uri = uri[1:] 
    345345                try : 
    346                     (backend, destination) = uri.split(":", 1)  
     346                    (backend, destination) = uri.split(":", 1) 
    347347                    if backend not in ("ipp", "http", "https", "lpd", "socket") : 
    348348                        raise ValueError 
    349                 except ValueError :     
     349                except ValueError : 
    350350                    pass 
    351                 else :         
     351                else : 
    352352                    while destination.startswith("/") : 
    353353                        destination = destination[1:] 
    354                     checkauth = destination.split("@", 1)     
     354                    checkauth = destination.split("@", 1) 
    355355                    if len(checkauth) == 2 : 
    356356                        destination = checkauth[1] 
    … …  
    362362                        except ValueError : 
    363363                            port = 9100 
    364                     else :     
     364                    else : 
    365365                        (hostname, port) = parts[0], 9100 
    366                          
     366 
    367367                    if self.supportsSNMP(hostname, "public") : 
    368368                        accounter = "hardware(snmp)" 
    … …  
    371371                    elif self.supportsPJL(hostname, 9101) : 
    372372                        accounter = "hardware(pjl:9101)" 
    373                     elif self.supportsPJL(hostname, port) :     
     373                    elif self.supportsPJL(hostname, port) : 
    374374                        accounter = "hardware(pjl:%s)" % port 
    375                      
    376             print "preaccounter : software()"  
     375 
     376            print "preaccounter : software()" 
    377377            print "accounter : %s" % accounter 
    378378            print 
    379379        print "--- CUT ---" 
    380          
     380 
    381381    def main(self, names, options) : 
    382382        """Intializes PyKota's database.""" 
    383383        self.adminOnly() 
    384          
     384 
    385385        if not names : 
    386386            names = ["*"] 
    387              
     387 
    388388        self.printInfo(_("Please be patient...")) 
    389389        dryrun = not options["force"] 
    390390        if dryrun : 
    391391            self.printInfo(_("Don't worry, the database WILL NOT BE MODIFIED.")) 
    392         else :     
     392        else : 
    393393            self.printInfo(_("Please WORRY NOW, the database WILL BE MODIFIED.")) 
    394              
    395         if options["dousers"] :     
    396             if not options["uidmin"] :     
     394 
     395        if options["dousers"] : 
     396            if not options["uidmin"] : 
    397397                self.printInfo(_("System users will have a print account as well !"), "warn") 
    398398                uidmin = 0 
    399             else :     
     399            else : 
    400400                try : 
    401401                    uidmin = int(options["uidmin"]) 
    402                 except :     
     402                except : 
    403403                    try : 
    404404                        uidmin = pwd.getpwnam(options["uidmin"])[2] 
    405                     except KeyError, msg :     
     405                    except KeyError, msg : 
    406406                        raise PyKotaCommandLineError, _("Unknown username %s : %s") \ 
    407407                                                   % (options["uidmin"], msg) 
    408                          
    409             if not options["uidmax"] :     
     408 
     409            if not options["uidmax"] : 
    410410                uidmax = sys.maxint 
    411             else :     
     411            else : 
    412412                try : 
    413413                    uidmax = int(options["uidmax"]) 
    414                 except :     
     414                except : 
    415415                    try : 
    416416                        uidmax = pwd.getpwnam(options["uidmax"])[2] 
    417                     except KeyError, msg :     
     417                    except KeyError, msg : 
    418418                        raise PyKotaCommandLineError, _("Unknown username %s : %s") \ 
    419419                                                   % (options["uidmax"], msg) 
    420              
    421             if uidmin > uidmax :             
     420 
     421            if uidmin > uidmax : 
    422422                (uidmin, uidmax) = (uidmax, uidmin) 
    423423            users = self.listUsers(uidmin, uidmax) 
    424         else :     
     424        else : 
    425425            users = [] 
    426              
    427         if options["dogroups"] :     
    428             if not options["gidmin"] :     
     426 
     427        if options["dogroups"] : 
     428            if not options["gidmin"] : 
    429429                self.printInfo(_("System groups will have a print account as well !"), "warn") 
    430430                gidmin = 0 
    431             else :     
     431            else : 
    432432                try : 
    433433                    gidmin = int(options["gidmin"]) 
    434                 except :     
     434                except : 
    435435                    try : 
    436436                        gidmin = grp.getgrnam(options["gidmin"])[2] 
    437                     except KeyError, msg :     
     437                    except KeyError, msg : 
    438438                        raise PyKotaCommandLineError, _("Unknown groupname %s : %s") \ 
    439439                                                   % (options["gidmin"], msg) 
    440                          
    441             if not options["gidmax"] :     
     440 
     441            if not options["gidmax"] : 
    442442                gidmax = sys.maxint 
    443             else :     
     443            else : 
    444444                try : 
    445445                    gidmax = int(options["gidmax"]) 
    446                 except :     
     446                except : 
    447447                    try : 
    448448                        gidmax = grp.getgrnam(options["gidmax"])[2] 
    449                     except KeyError, msg :     
     449                    except KeyError, msg : 
    450450                        raise PyKotaCommandLineError, _("Unknown groupname %s : %s") \ 
    451451                                                   % (options["gidmax"], msg) 
    452              
    453             if gidmin > gidmax :             
     452 
     453            if gidmin > gidmax : 
    454454                (gidmin, gidmax) = (gidmax, gidmin) 
    455455            groups = self.listGroups(gidmin, gidmax, users) 
    … …  
    458458                    if not members : 
    459459                        del groups[groupname] 
    460         else :     
     460        else : 
    461461            groups = [] 
    462              
     462 
    463463        printers = self.listPrinters(names) 
    464464        if printers : 
    … …  
    466466            self.createUsers([entry[0] for entry in users], printers, dryrun) 
    467467            self.createGroups(groups, printers, dryrun) 
    468          
     468 
    469469        if dryrun : 
    470470            self.printInfo(_("Simulation terminated.")) 
    471         else :     
     471        else : 
    472472            self.printInfo(_("Database initialized !")) 
    473         
    474         if options["doconf"] :     
     473 
     474        if options["doconf"] : 
    475475            self.hintConfig(printers) 
    476                      
    477                       
    478 if __name__ == "__main__" :  
     476 
     477 
     478if __name__ == "__main__" : 
    479479    retcode = 0 
    480480    try : 
    … …  
    483483                        "emptygroups", "force", "uidmin=", "uidmax=", \ 
    484484                        "gidmin=", "gidmax=", "doconf"] 
    485          
     485 
    486486        # Initializes the command line tool 
    487487        manager = PKTurnKey(doc=__doc__) 
    488488        manager.deferredInit() 
    489          
     489 
    490490        # parse and checks the command line 
    491491        (options, args) = manager.parseCommandline(sys.argv[1:], \ 
    … …  
    493493                                                   long_options, \ 
    494494                                                   allownothing=1) 
    495          
     495 
    496496        # sets long options 
    497497        options["help"] = options["h"] or options["help"] 
    … …  
    506506        options["gidmax"] = options["G"] or options["gidmax"] 
    507507        options["doconf"] = options["c"] or options["doconf"] 
    508          
     508 
    509509        if options["uidmin"] or options["uidmax"] : 
    510510            if not options["dousers"] : 
    511511                manager.printInfo(_("The --uidmin or --uidmax command line option implies --dousers as well."), "warn") 
    512             options["dousers"] = 1     
    513              
     512            options["dousers"] = 1 
     513 
    514514        if options["gidmin"] or options["gidmax"] : 
    515515            if not options["dogroups"] : 
    516516                manager.printInfo(_("The --gidmin or --gidmax command line option implies --dogroups as well."), "warn") 
    517517            options["dogroups"] = 1 
    518          
     518 
    519519        if options["dogroups"] : 
    520520            if not options["dousers"] : 
    521521                manager.printInfo(_("The --dogroups command line option implies --dousers as well."), "warn") 
    522             options["dousers"] = 1     
    523              
     522            options["dousers"] = 1 
     523 
    524524        if options["help"] : 
    525525            manager.display_usage_and_quit() 
    … …  
    528528        else : 
    529529            retcode = manager.main(args, options) 
    530     except KeyboardInterrupt :         
     530    except KeyboardInterrupt : 
    531531        logerr("\nInterrupted with Ctrl+C !\n") 
    532532        retcode = -3 
    533     except PyKotaCommandLineError, msg :     
     533    except PyKotaCommandLineError, msg : 
    534534        logerr("%s : %s\n" % (sys.argv[0], msg)) 
    535535        retcode = -2 
    536     except SystemExit :         
     536    except SystemExit : 
    537537        pass 
    538538    except : 
    539539        try : 
    540540            manager.crashed("pkturnkey failed") 
    541         except :     
     541        except : 
    542542            crashed("pkturnkey failed") 
    543543        retcode = -1 
    … …  
    545545    try : 
    546546        manager.storage.close() 
    547     except (TypeError, NameError, AttributeError) :     
     547    except (TypeError, NameError, AttributeError) : 
    548548        pass 
    549          
    550     sys.exit(retcode)     
     549 
     550    sys.exit(retcode)