Changeset 2937


Ignore:
Timestamp:
08/10/07 17:35:32 (12 years ago)
Author:
pjkersha
Message:

ndg.security.server.MyProxy?: added CmdLineClient? class for MyProxy? client script. Part complete.

Location:
TI12-security/trunk/python
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/Makefile

    r2909 r2937  
    3939force: replace 
    4040 
     41NDG_EGG_DIST_USER=badc 
     42NDG_EGG_DIST_HOST=zonda.badc.rl.ac.uk 
     43NDG_EGG_DIST_DIR=/var/www/ndg_site/htdocs/dist 
     44 
     45install_eggs: eggs 
     46        scp dist/*.egg ndg.*/dist/*.egg \ 
     47        ${NDG_EGG_DIST_USER}@${NDG_EGG_DIST_HOST}:${NDG_EGG_DIST_DIR} 
     48 
    4149# Generate HTML from embedded epydoc text in source code. 
    4250EPYDOC=epydoc 
  • TI12-security/trunk/python/ndg.security.client/setup.py

    r2909 r2937  
    3232setup( 
    3333    name =                      'ndg_security_client', 
    34     version =                   '0.8.4', 
     34    version =                   '0.8.5', 
    3535    description =               'NERC DataGrid Security Utilities', 
    3636    long_description =          'Software for securing NDG resources', 
  • TI12-security/trunk/python/ndg.security.common/setup.py

    r2909 r2937  
    6161setup( 
    6262    name =                      'ndg_security_common', 
    63     version =                   '0.8.4', 
     63    version =                   '0.8.5', 
    6464    description = \ 
    6565'''NERC DataGrid Security virtual package containing common utilities used 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/MyProxy.py

    r2927 r2937  
    320320        # Must be version 3 for MyProxy 
    321321        context = SSL.Context(protocol='sslv3') 
    322         context.load_verify_locations(cafile=self.__prop['caCertFile']) 
     322        if 'caCertFile' in self.__prop: 
     323            context.load_verify_locations(cafile=self.__prop['caCertFile']) 
    323324         
    324325        if ownerCertFile and ownerKeyFile: 
    325             context.load_cert_chain(ownerCertFile, 
     326            try: 
     327                context.load_cert_chain(ownerCertFile, 
    326328                                keyfile=ownerKeyFile, 
    327329                                callback=lambda *ar, **kw: ownerPassphrase) 
    328                  
     330            except Exception, e: 
     331                raise MyProxyClientError, \ 
     332                            "Error loading cert. and key for SSL connection"  
     333                             
    329334            # Stop if peer's certificate can't be verified 
    330335            context.set_allow_unknown_ca(False) 
     
    489494        Exceptions:  GetError, RetrieveError 
    490495         
     496        @type username: string 
    491497        @param username: username selected for credential 
     498        @type ownerCertFile: string 
    492499        @param ownerCertFile: certificate used for client authentication with 
    493500        the MyProxy server SSL connection.  This ID will be set as the owner 
     
    495502        credentials with myproxy-destroy or the destroy method.  If not set, 
    496503        this argument defaults to $GLOBUS_LOCATION/etc/hostcert.pem  
     504        @type ownerKeyFile: string  
    497505        @param ownerKeyFile: corresponding private key file.  See explanation 
    498506        for ownerCertFile 
     507        @type ownerPassphrase: string 
    499508        @param ownerPassphrase: passphrase for ownerKeyFile.  Omit if the 
    500509        private key is not password protected. 
    501         @return none 
    502510        """ 
    503511        globusLoc = os.environ.get('GLOBUS_LOCATION') 
    504         if not ownerCertFile or not ownerKeyFile: 
    505             if globusLoc: 
    506                 ownerCertFile = os.path.join(globusLoc,  
    507                                          *MyProxyClient._hostCertSubDirPath) 
    508                 ownerKeyFile = os.path.join(globusLoc,  
    509                                          *MyProxyClient._hostKeySubDirPath) 
    510             else: 
    511                 raise MyProxyClientError, \ 
    512             "No client authentication cert. and private key file were given" 
     512#        if not ownerCertFile or not ownerKeyFile: 
     513#            if globusLoc: 
     514#                ownerCertFile = os.path.join(globusLoc,  
     515#                                         *MyProxyClient._hostCertSubDirPath) 
     516#                ownerKeyFile = os.path.join(globusLoc,  
     517#                                         *MyProxyClient._hostKeySubDirPath) 
     518#            else: 
     519#                raise MyProxyClientError, \ 
     520#            "No client authentication cert. and private key file were given" 
    513521 
    514522        # Set-up SSL connection 
     
    667675        """Upload credentials to the server 
    668676         
    669         Exceptions:  GetError, RetrieveError 
    670          
     677        @raise GetError: 
     678        @raise RetrieveError: 
     679         
     680        @type username: string 
    671681        @param username: username selected for new credential 
     682        @type passphrase: string 
    672683        @param passphrase: pass-phrase for new credential.  This is the pass 
    673684        phrase which protects keyfile. 
     685        @type certFile: string 
    674686        @param certFile: user's X.509 certificate in PEM format 
     687        @type keyFile: string 
    675688        @param keyFile: equivalent private key file in PEM format 
     689        @type ownerCertFile: string 
    676690        @param ownerCertFile: certificate used for client authentication with 
    677691        the MyProxy server SSL connection.  This ID will be set as the owner 
     
    680694        this argument defaults to $GLOBUS_LOCATION/etc/hostcert.pem or if this 
    681695        is not set, certFile 
     696        @type ownerKeyFile: string 
    682697        @param ownerKeyFile: corresponding private key file.  See explanation 
    683698        for ownerCertFile 
     699        @type ownerPassphrase: string  
    684700        @param ownerPassphrase: passphrase for ownerKeyFile.  Omit if the 
    685701        private key is not password protected.  Nb. keyFile is expected to 
    686702        be passphrase protected as this will be the passphrase used for 
    687703        logon / getDelegation. 
     704        @type Force: bool 
    688705        @param force: set to True to overwrite any existing creds with the 
    689706        same username.  If, force=False a check is made with a call to info. 
    690707        If creds already, exist exit without proceeding 
    691         @return none 
    692708        """ 
    693709         
     
    838854#_____________________________________________________________________________    
    839855def main(): 
    840     import sys 
    841     import optparse 
    842     import getpass 
    843      
    844     parser = optparse.OptionParser() 
    845     parser.add_option("-i",  
    846                       "--info",  
    847                       dest="info",  
    848                       default=False, 
    849                       action="store_true", 
    850                       help="check whether a credential exists") 
    851  
    852     parser.add_option("-z",  
    853                       "--destroy",  
    854                       dest="destroy",  
    855                       default=False, 
    856                       action="store_true", 
    857                       help="destroy credential") 
    858  
    859     parser.add_option("-C",  
    860                       "--change-pass-phrase",  
    861                       dest="changePassphrase",  
    862                       default=False, 
    863                       action="store_true", 
    864                       help="change pass-phrase protecting credential") 
    865  
    866     parser.add_option("-g",  
    867                       "--get-delegation",  
    868                       dest="getDelegation",  
    869                       default=False, 
    870                       action="store_true", 
    871                       help="Get delegation / logon") 
    872      
    873     parser.add_option("-c",  
    874                       "--certfile",  
    875                       dest="certFile",  
    876                       default=None, 
    877                       help="Certificate to be stored") 
    878      
    879     parser.add_option("-y",  
    880                       "--keyfile",  
    881                       dest="keyFile",  
    882                       default=None, 
    883                       help="Private key to be stored") 
    884      
    885     parser.add_option("-w",  
    886                       "--keyfile-passphrase",  
    887                       dest="ownerPassphrase",  
    888                       default=None, 
    889                       help="Pass-phrase for Private key used for SSL client") 
    890  
    891     parser.add_option("-s",  
    892                       "--pshost",  
    893                       dest="host",  
    894                       help="The hostname of the MyProxy server to contact") 
    895      
    896     parser.add_option("-p",  
    897                       "--psport",  
    898                       dest="port",  
    899                       default=7512, 
    900                       type="int", 
    901                       help="The port of the MyProxy server to contact") 
    902      
    903     parser.add_option("-l",  
    904                       "--username",  
    905                       dest="username",  
    906                       help=\ 
    907     "The username with which the credential is stored on the MyProxy server") 
    908  
    909     parser.add_option("-o",  
    910                       "--out",  
    911                       dest="outfile",  
    912                       help=\ 
    913     "The username with which the credential is stored on the MyProxy server") 
    914  
    915     parser.add_option("-t",  
    916                       "--proxy-lifetime",  
    917                       dest="lifetime",  
    918                       default=43200, 
    919                       type="int", 
    920                       help=\ 
    921     "The username with which the credential is stored on the MyProxy server") 
    922  
    923     (options, args) = parser.parse_args() 
    924      
    925  
    926     # process options     
    927     username = options.username 
    928     if not username: 
    929         if sys.platform == 'win32': 
    930             username = os.environ["USERNAME"] 
     856     
     857    import pdb;pdb.set_trace() 
     858    try: 
     859        CmdLineClient()             
     860    except Exception,e: 
     861        print "Error: ", e 
     862        sys.exit(1) 
     863 
     864#  help="check whether a credential exists") 
     865# 
     866#  help="destroy credential") 
     867# 
     868#  help="change pass-phrase protecting credential") 
     869 
     870import sys 
     871import optparse 
     872import getpass 
     873 
     874class CmdLineClientError(Exception): 
     875    """Errors related to CmdLineClient class""" 
     876     
     877class CmdLineClient(object): 
     878    """Command line interface to MyProxyClient class.  Where possible it  
     879    supports the same options as the Globus myproxy-* client commands""" 
     880     
     881    run = {'info': 'runInfo',  
     882           'logon': 'runLogon', 
     883           'get-delegation': 'runGetDelegation', 
     884           'destroy': 'runDestroy',  
     885           'change-pass': 'runChangePassphrase', 
     886           'store': 'runStore'} 
     887 
     888    initOpts = {'info': '_addInfoOpts',  
     889            'logon': '_addLogonOpts', 
     890            'get-delegation': '_addGetDelegationOpts', 
     891            'destroy': '_addDestroyOpts',  
     892            'change-pass': '_addChangePassphraseOpts', 
     893            'store': '_addStoreOpts'} 
     894     
     895    usage = "usage: %prog" + " [%s] arg1 arg2" % '|'.join(run.keys()) 
     896     
     897    def __init__(self): 
     898        """Parse the command line and run the appropriate command""" 
     899 
     900        self.parser = optparse.OptionParser(usage=self.__class__.usage) 
     901 
     902        # Get command - expected to be 1st arg 
     903        if len(sys.argv) > 1: 
     904            cmd = sys.argv[1] 
     905            if cmd not in self.__class__.run: 
     906                self.parser.error('"%s" command option not recognised' % cmd) 
    931907        else: 
    932             import pwd 
    933             username = pwd.getpwuid(os.geteuid())[0] 
    934  
    935     hostname = options.host or os.environ.get('MYPROXY_SERVER') 
    936     myProxy = MyProxyClient(hostname=hostname, 
    937                             port=options.port, 
    938                             O='NDG', 
    939                             OU='BADC') 
    940      
    941     if options.getDelegation: 
     908            self.parser.error('No command option set') 
    942909                 
    943         outfile = options.outfile 
     910        # Add options based on the command set 
     911        self._addGenericOpts() 
     912        getattr(self, self.initOpts[cmd])() 
     913         
     914        # Omit command options as parser won't understand it 
     915        (self.opts, args) = self.parser.parse_args(args=sys.argv[2:])      
     916     
     917        # Process generic options 
     918         
     919        # Not all commands require username option - for those that do, check  
     920        # to see if it was set or omitted 
     921        if hasattr(self.opts, 'username') and not self.opts.username: 
     922            if sys.platform == 'win32': 
     923                self.opts.username = os.environ["USERNAME"] 
     924            else: 
     925                import pwd 
     926                self.opts.username = pwd.getpwuid(os.geteuid())[0] 
     927     
     928        self.myProxy = MyProxyClient(hostname=self.opts.host, 
     929                                     port=self.opts.port)#, 
     930#                                     O='NDG', 
     931#                                     OU='BADC') 
     932 
     933        # Run the command 
     934        getattr(self, self.run[cmd])() 
     935 
     936                 
     937    def _addGenericOpts(self): 
     938        """Generic options applying to all commands""" 
     939        self.parser.add_option("-s",  
     940                          "--pshost",  
     941                          dest="host", 
     942                          default=os.environ.get('MYPROXY_SERVER'), 
     943                          help="The hostname of the MyProxy server to contact") 
     944 
     945        defPort = int(os.environ.get('MYPROXY_SERVER_PORT') or '7512') 
     946        self.parser.add_option("-p",  
     947                          "--psport",  
     948                          dest="port",  
     949                          default=defPort, 
     950                          type="int", 
     951                          help="The port of the MyProxy server to contact") 
     952 
     953    def _addInfoOpts(self): 
     954        """Add command line options for info""" 
     955        self.parser.add_option("-l",  
     956                          "--username",  
     957                          dest="username",  
     958                          help="Username for the delegated proxy") 
     959 
     960        self.parser.add_option("-C",  
     961                          "--owner-certfile",  
     962                          dest="ownerCertFile",  
     963                          help=\ 
     964"""Certificate for owner of credentials to be queried.  If omitted, it  
     965defaults to $GLOBUS_LOCATION/etc/hostcert.pem.""") 
     966         
     967        self.parser.add_option("-K",  
     968                          "--owner-keyfile",  
     969                          dest="ownerKeyFile",  
     970                          default=None, 
     971                          help=\ 
     972"""Private key for owner of credentials to be stored.  If omitted, it defaults 
     973to $GLOBUS_LOCATION/etc/hostkey.pem.""") 
     974        
     975        self.parser.add_option("-w",  
     976                          "--owner-keyfile-passphrase",  
     977                          dest="ownerPassphrase",  
     978                          default=None, 
     979                          help=\ 
     980                          "Pass-phrase for Private key used for SSL client") 
     981         
     982    def _addLogonOpts(self): 
     983        """Add command line options for logon""" 
     984        self.parser.add_option("-l",  
     985                               "--username",  
     986                               dest="username",  
     987                               help="Username for the delegated proxy") 
     988 
     989        self.parser.add_option("-t",  
     990                               "--proxy_lifetime",  
     991                               dest="lifetime",  
     992                               default=43200, # = 12 hours in seconds 
     993                               type="int", 
     994                               help=\ 
     995            "Lifetime of proxies delegated by the server (default 12 hours)") 
     996 
     997        self.parser.add_option("-o",  
     998                               "--out",  
     999                               dest="outfile",  
     1000                               help="Location of delegated proxy") 
     1001 
     1002    def _addGetDelegationOpts(self): 
     1003        """Add command line options for Get Delegation""" 
     1004        self._addGenericOpts() 
     1005        self._addLogonOpts() 
     1006 
     1007    def _addDestroyOpts(self): 
     1008        """Add command line options for destroy""" 
     1009        self.parser.add_option("-l",  
     1010                               "--username",  
     1011                               dest="username",  
     1012                               help=\ 
     1013                       "Username corresponding to credentials to be removed") 
     1014 
     1015    def _addChangePassphraseOpts(self): 
     1016        """Add command line options for change pass-phrase""" 
     1017        self.parser.add_option("-l",  
     1018                          "--username",  
     1019                          dest="username",  
     1020                          help="Username for the target proxy") 
     1021         
     1022    def _addStoreOpts(self): 
     1023        """Add command line options for store""" 
     1024        self.parser.add_option("-l",  
     1025                               "--username",  
     1026                               dest="username",  
     1027                               help=\ 
     1028                       "Username corresponding to credentials to be stored") 
     1029         
     1030        self.parser.add_option("-c",  
     1031                          "--certfile",  
     1032                          dest="certFile",  
     1033                          default=None, 
     1034                          help="Certificate to be stored") 
     1035         
     1036        self.parser.add_option("-y",  
     1037                          "--keyfile",  
     1038                          dest="keyFile",  
     1039                          default=None, 
     1040                          help="Private key to be stored") 
     1041 
     1042        self.parser.add_option("-C",  
     1043                          "--owner-certfile",  
     1044                          dest="ownerCertFile",  
     1045                          help=\ 
     1046"""Cert. for owner of credentials to be stored.  If omitted, it defaults to 
     1047$GLOBUS_LOCATION/etc/hostcert.pem.  If this is not readable, the cert. to be 
     1048stored is set as the owner.""") 
     1049         
     1050        self.parser.add_option("-K",  
     1051                          "--owner-keyfile",  
     1052                          dest="ownerKeyFile",  
     1053                          default=None, 
     1054                          help=\ 
     1055"""Private key for owner of credentials to be stored.  If omitted, it defaults 
     1056to $GLOBUS_LOCATION/etc/hostcert.pem.""") 
     1057        
     1058        self.parser.add_option("-w",  
     1059                          "--owner-keyfile-passphrase",  
     1060                          dest="ownerPassphrase",  
     1061                          default=None, 
     1062                          help=\ 
     1063                          "Pass-phrase for Private key used for SSL client") 
     1064 
     1065        self.parser.add_option("-t",  
     1066                               "--proxy_lifetime",  
     1067                               dest="lifetime",  
     1068                               default=43200, # = 12 hours in seconds 
     1069                               type="int", 
     1070                               help=\ 
     1071            "Lifetime of proxies delegated by the server (default 12 hours)") 
     1072     
     1073    def runGetDelegation(self): 
     1074        """Call MyProxyClient.getDelegation""" 
     1075        self.runLogon() 
     1076         
     1077    def runLogon(self): 
     1078        """Call MyProxyClient.logon""" 
     1079        outfile = self.opts.outfile 
    9441080        if not outfile: 
    9451081            if sys.platform == 'win32': 
    9461082                outfile = 'proxy' 
    947             elif sys.platform in ['linux2','darwin']: 
     1083            elif sys.platform in ('linux2', 'darwin'): 
    9481084                outfile = '/tmp/x509up_u%s' % (os.getuid()) 
    9491085     
     
    9521088             
    9531089        # Retrieve proxy cert 
     1090        creds = self.myProxy.logon(username,  
     1091                                   passphrase,  
     1092                                   lifetime=self.opts.lifetime) 
     1093        open(outfile, 'w').write(''.join(creds)) 
    9541094        try: 
    955             creds = myProxy.logon(username,  
    956                                   passphrase,  
    957                                   lifetime=options.lifetime) 
    958             open(outfile, 'w').write(''.join(creds)) 
    959             try: 
    960                 # Make sure permssions are set correctly 
    961                 os.chmod(outfile, 600) 
    962             except Exception: 
    963                 # Don't leave the file lying around if couldn't change it's 
    964                 # permissions 
    965                 os.unlink(outfile) 
    966                  
    967             print "A proxy has been received for user %s in %s." % \ 
    968                 (username, outfile) 
    969              
    970         except Exception,e: 
    971             print "Error:", e 
    972             sys.exit(1) 
    973              
    974     elif options.changePassphrase: 
    975                  
     1095            # Make sure permssions are set correctly 
     1096            os.chmod(outfile, 600) 
     1097        except Exception: 
     1098            # Don't leave the file lying around if couldn't change it's 
     1099            # permissions 
     1100            os.unlink(outfile) 
     1101             
     1102            raise CmdLineClientError, \ 
     1103                'Unable to set 0600 permissions for proxy file "%s"'%outfile 
     1104             
     1105        print "A proxy has been received for user %s in %s." % \ 
     1106            (username, outfile) 
     1107             
     1108    def runChangePassphrase(self): 
     1109        """Call MyProxyClient.changePassphrase""" 
     1110         
    9761111        # Get MyProxy password 
    9771112        passphrase = getpass.getpass(\ 
     
    9841119                     prompt='Verifying - Enter new MyProxy pass phrase: '): 
    9851120            raise Exception, "Pass-phrases entered don't match" 
    986          
    987          
    988         # Retrieve proxy cert 
    989         try: 
    990             myProxy.changePassphrase(username, 
     1121                 
     1122        self.myProxy.changePassphrase(username, 
    9911123                             passphrase, 
    9921124                             newPassphrase,  
    993                              options.certFile, 
    994                              options.keyFile, 
     1125                             self.opts.certFile, 
     1126                             self.opts.keyFile, 
    9951127                             ownerPassphrase=open('../tmp2').read().strip())             
    996         except Exception,e: 
    997             print "Error:", e 
    998             sys.exit(1) 
    9991128                 
    1000     elif options.info: 
    1001         try: 
    1002             credExists, errorTxt, fields = myProxy.info(username,  
    1003                              options.certFile, 
    1004                              options.keyFile, 
    1005                              ownerPassphrase=open('../tmp2').read().strip()) 
    1006             if credExists: 
    1007                 print "username: %s" % username 
    1008                 print "owner: %s" % fields['CRED_OWNER'] 
    1009                 print "  time left: %d" % \ 
    1010                         (fields['CRED_END_TIME'] - fields['CRED_START_TIME']) 
    1011             else: 
    1012                 ownerCert = X509.load_cert(options.certFile) 
    1013                 ownerCertDN = '/' + \ 
    1014                     ownerCert.get_subject().as_text().replace(', ', '/') 
    1015                 print "no credentials found for user %s, owner \"%s\"" % \ 
    1016                     (username, ownerCertDN) 
    1017  
    1018         except Exception, e: 
    1019             print "Error:", e 
    1020             sys.exit(1) 
     1129    def runInfo(self): 
     1130        """Call MyProxyClient.info""" 
     1131        credExists, errorTxt, fields = self.myProxy.info(self.opts.username,  
     1132                             ownerCertFile=self.opts.ownerCertFile, 
     1133                             ownerKeyFile=self.opts.ownerKeyFile, 
     1134                             ownerPassphrase=self.opts.ownerPassphrase) 
     1135        if errorTxt: 
     1136            raise CmdLineClientError, "User %s: %s" % (self.opts.username,  
     1137                                                       errorTxt) 
    10211138                 
    1022     elif options.destroy: 
    1023         try: 
    1024             myProxy.destroy(username,  
    1025                             ownerCertFile=options.certFile, 
    1026                             ownerKeyFile=options.keyFile, 
     1139        elif credExists: 
     1140            print "username: %s" % self.opts.username 
     1141            print "owner: %s" % fields['CRED_OWNER'] 
     1142            print "  time left: %d" % \ 
     1143                    (fields['CRED_END_TIME'] - fields['CRED_START_TIME']) 
     1144        else: 
     1145            ownerCert = ''#X509.load_cert(self.opts.ownerCertFile) 
     1146            ownerCertDN = ''#'/' + \ 
     1147                #ownerCert.get_subject().as_text().replace(', ', '/') 
     1148            print "no credentials found for user %s, owner \"%s\"" % \ 
     1149                (self.opts.username, ownerCertDN) 
     1150                 
     1151    def runDestroy(self): 
     1152        """Call MyProxyClient.destroy""" 
     1153        self.myProxy.destroy(self.opts.username,  
     1154                            ownerCertFile=self.opts.certFile, 
     1155                            ownerKeyFile=self.opts.keyFile, 
    10271156                            ownerPassphrase=open('../tmp2').read().strip()) 
    1028             
    1029         except Exception, e: 
    1030             print "Error:", e 
    1031             sys.exit(1) 
    1032     else: 
    1033         try: 
    1034             myProxy.store(username,  
    1035                           options.certFile, 
    1036                           options.keyFile, 
    1037                           ownerCertFile=options.certFile, 
    1038                           ownerKeyFile=options.keyFile, 
    1039                           ownerPassphrase=open('../tmp2').read().strip(), 
    1040                           lifetime=options.lifetime) 
    1041             
    1042         except Exception, e: 
    1043             print "Error:", e 
    1044             sys.exit(1) 
    1045      
     1157         
     1158    def runStore(self): 
     1159        self.myProxy.store(self.opts.username,  
     1160                          self.opts.certFile, 
     1161                          self.opts.keyFile, 
     1162                          ownerCertFile=self.opts.certFile, 
     1163                          ownerKeyFile=self.opts.keyFile, 
     1164                          ownerPassphrase=open('./tmp').read().strip(), 
     1165                          lifetime=self.opts.lifetime) 
     1166 
     1167 
     1168if __name__ == "__main__": 
     1169    main() 
  • TI12-security/trunk/python/ndg.security.server/setup.py

    r2909 r2937  
    3333] 
    3434 
     35# Make a script interface to MyProxy client 
     36_entryPoints = {'console_scripts': \ 
     37                ['myproxy-client = ndg.security.server.MyProxy:main']} 
    3538     
    3639setup( 
    3740    name =                      'ndg_security_server', 
    38     version =                   '0.8.4', 
     41    version =                   '0.8.5', 
    3942    description =               'NERC DataGrid Security Services', 
    4043    long_description =          'Server side component for securing NDG resources', 
     
    7477                             'ndg.security.server.SessionMgr': ['*.sh'], 
    7578                             'ndg.security.server.ca': ['*.sh']}, 
     79    entry_points =           _entryPoints, 
    7680#    data_files =            [('share',  
    7781#                              [os.path.join('share', 'ndg-aa'),  
  • TI12-security/trunk/python/ndg.security.test/setup.py

    r2909 r2937  
    3434setup( 
    3535    name =                      'ndg_security_test', 
    36     version =                   '0.8.4', 
     36    version =                   '0.8.5', 
    3737    description =               'NERC DataGrid Security Unit tests', 
    3838    long_description =          'Unit tests client - server side', 
  • TI12-security/trunk/python/setup.py

    r2909 r2937  
    2626setup( 
    2727    name =                      'ndg_security', 
    28     version =                   '0.8.4', 
     28    version =                   '0.8.5', 
    2929    description =               'NERC DataGrid Security Utilities', 
    3030    long_description =          'Software for securing NDG resources', 
Note: See TracChangeset for help on using the changeset viewer.