Esempio n. 1
0
 def _getCurrentUser( self ):
   res = getProxyInfo( False, False )
   if not res['OK']:
     return self._errorReport( 'No proxy found in local environment', res['Message'] )
   proxyInfo = res['Value']
   gLogger.debug( formatProxyInfoAsString( proxyInfo ) )
   if 'group 'not in proxyInfo:
     return self._errorReport( 'Proxy information does not contain the group', res['Message'] )
   res = getDNForUsername( proxyInfo['username'] )
   if not res['OK']:
     return self._errorReport( 'Failed to get proxies for user', res['Message'] )
   return S_OK( proxyInfo['username'] )
Esempio n. 2
0
    def execute(self):

        self.log.info("Start Execution")
        result = getProxyInfo()
        if not result["OK"]:
            return result
        infoDict = result["Value"]
        self.log.info(formatProxyInfoAsString(infoDict))

        self.__lookForCE()
        self.__infoFromCE()
        self.log.info("End Execution")
        return S_OK()
Esempio n. 3
0
  def execute( self ):

    self.log.info( "Start Execution" )
    result = getProxyInfo()
    if not result[ 'OK' ]:
      return result
    infoDict = result[ 'Value' ]
    self.log.info( formatProxyInfoAsString( infoDict ) )

    #Get a "fresh" copy of the CS data
    result = self.csAPI.downloadCSData()
    if not result[ 'OK' ]:
      self.log.warn( "Could not download a fresh copy of the CS data", result[ 'Message' ] )

    self.__lookForCE()
    self.__infoFromCE()
    self.log.info( "End Execution" )
    return S_OK()
Esempio n. 4
0
    def _monitorProxy(self, pilotProxy, payloadProxy):
        """Base class for the monitor and update of the payload proxy, to be used in
      derived classes for the basic renewal of the proxy, if further actions are
      necessary they should be implemented there
    """
        retVal = getProxyInfo(payloadProxy)
        if not retVal["OK"]:
            self.log.error("Could not get payload proxy info", retVal)
            return retVal
        self.log.verbose("Payload Proxy information:\n%s" % formatProxyInfoAsString(retVal["Value"]))

        payloadProxyDict = retVal["Value"]
        payloadSecs = payloadProxyDict["chain"].getRemainingSecs()["Value"]
        if payloadSecs > self.minProxyTime:
            self.log.verbose("No need to renew payload Proxy")
            return S_OK()

        # if there is no pilot proxy, assume there is a certificate and try a renewal
        if not pilotProxy:
            self.log.info("Using default credentials to get a new payload Proxy")
            return gProxyManager.renewProxy(
                proxyToBeRenewed=payloadProxy,
                minLifeTime=self.minProxyTime,
                newProxyLifeTime=self.defaultProxyTime,
                proxyToConnect=pilotProxy,
            )

        # if there is pilot proxy
        retVal = getProxyInfo(pilotProxy)
        if not retVal["OK"]:
            return retVal
        pilotProxyDict = retVal["Value"]

        if not "groupProperties" in pilotProxyDict:
            self.log.error("Invalid Pilot Proxy", "Group has no properties defined")
            return S_ERROR("Proxy has no group properties defined")

        pilotProps = pilotProxyDict["groupProperties"]

        # if running with a pilot proxy, use it to renew the proxy of the payload
        if Properties.PILOT in pilotProps or Properties.GENERIC_PILOT in pilotProps:
            self.log.info("Using Pilot credentials to get a new payload Proxy")
            return gProxyManager.renewProxy(
                proxyToBeRenewed=payloadProxy,
                minLifeTime=self.minProxyTime,
                newProxyLifeTime=self.defaultProxyTime,
                proxyToConnect=pilotProxy,
            )

        # if we are running with other type of proxy check if they are for the same user and group
        # and copy the pilot proxy if necessary

        self.log.info("Trying to copy pilot Proxy to get a new payload Proxy")
        pilotProxySecs = pilotProxyDict["chain"].getRemainingSecs()["Value"]
        if pilotProxySecs <= payloadSecs:
            errorStr = "Pilot Proxy is not longer than payload Proxy"
            self.log.error(errorStr)
            return S_ERROR("Can not renew by copy: %s" % errorStr)

        # check if both proxies belong to the same user and group
        pilotDN = pilotProxyDict["chain"].getIssuerCert()["Value"].getSubjectDN()["Value"]
        retVal = pilotProxyDict["chain"].getDIRACGroup()
        if not retVal["OK"]:
            return retVal
        pilotGroup = retVal["Value"]

        payloadDN = payloadProxyDict["chain"].getIssuerCert()["Value"].getSubjectDN()["Value"]
        retVal = payloadProxyDict["chain"].getDIRACGroup()
        if not retVal["OK"]:
            return retVal
        payloadGroup = retVal["Value"]
        if pilotDN != payloadDN or pilotGroup != payloadGroup:
            errorStr = "Pilot Proxy and payload Proxy do not have same DN and Group"
            self.log.error(errorStr)
            return S_ERROR("Can not renew by copy: %s" % errorStr)

        if pilotProxyDict.get("hasVOMS", False):
            return pilotProxyDict["chain"].dumpAllToFile(payloadProxy)

        attribute = CS.getVOMSAttributeForGroup(payloadGroup)
        vo = CS.getVOMSVOForGroup(payloadGroup)

        retVal = VOMS().setVOMSAttributes(pilotProxyDict["chain"], attribute=attribute, vo=vo)
        if not retVal["OK"]:
            return retVal

        chain = retVal["Value"]
        return chain.dumpAllToFile(payloadProxy)
Esempio n. 5
0
  if result[ 'OK' ]:
    deviation = result[ 'Value' ]
    if deviation > 600:
      gLogger.error( "Your host clock seems to be off by more than TEN MINUTES! Thats really bad." )
    elif deviation > 180:
      gLogger.error( "Your host clock seems to be off by more than THREE minutes! Thats bad." )
    elif deviation > 60:
      gLogger.error( "Your host clock seems to be off by more than a minute! Thats not good." )


result = getProxyInfo( params.proxyLoc, not params.vomsEnabled )
if not result[ 'OK' ]:
  gLogger.error( result[ 'Message' ] )
  sys.exit( 1 )
infoDict = result[ 'Value' ]
gLogger.notice( formatProxyInfoAsString( infoDict ) )
if not infoDict['isProxy']:
  gLogger.error( '==============================\n!!! The proxy is not valid !!!' )

if params.steps:
  gLogger.notice( "== Steps extended info ==" )
  chain = infoDict[ 'chain' ]
  stepInfo = getProxyStepsInfo( chain )[ 'Value' ]
  gLogger.notice( formatProxyStepsInfoAsString( stepInfo ) )

def invalidProxy( msg ):
  gLogger.error( "Invalid proxy:", msg )
  sys.exit( 1 )

if params.uploadedInfo:
  result = gProxyManager.getUserProxiesInfo()