Python CSAPI.CSAPI类代码示例

class TestComponentInstallation( unittest.TestCase ):
  """
  Contains methods for testing of separate elements
  """

  def setUp( self ):
    self.host = 'localhost'
    self.notificationPort = 9154
    self.rootPwd = ''
    self.csClient = CSAPI()
    self.monitoringClient = ComponentMonitoringClient()
    self.client = SystemAdministratorClientCLI( self.host )

    self.csClient.downloadCSData()
    result = self.csClient.getCurrentCFG()
    if not result[ 'OK' ]:
      raise Exception( result[ 'Message' ] )
    cfg = result[ 'Value' ]

    setup = cfg.getOption( 'DIRAC/Setup', 'JenkinsSetup' )

    self.frameworkSetup = cfg.getOption( 'DIRAC/Setups/' + setup + '/Framework' )
    self.rootPwd = cfg.getOption( 'Systems/Databases/Password' )
    self.diracPwd = self.rootPwd

  def tearDown( self ):
    pass

  def __setCSElementStatus(self, elementName, elementType, statusType, status):
    """
    Sets on the CS the Elements status
    """

    # DIRAC doesn't store the status of ComputingElements nor FTS in the CS, so here we can just do nothing
    if elementType in ('ComputingElement', 'FTS'):
      return S_OK()

    # If we are here it is because elementType is either 'StorageElement' or 'Catalog'
    statuses = self.rssConfig.getConfigStatusType(elementType)
    if statusType not in statuses:
      gLogger.error("%s is not a valid statusType" % statusType)
      return S_ERROR("%s is not a valid statusType: %s" % (statusType, statuses))

    if elementType == 'StorageElement':
      cs_path = "/Resources/StorageElements"
    elif elementType == 'Catalog':
      cs_path = "/Resources/FileCatalogs"
      # FIXME: This a probably outdated location (new one is in /Operations/[]/Services/Catalogs)
      # but needs to be VO-aware
      statusType = 'Status'

    csAPI = CSAPI()
    csAPI.setOption("%s/%s/%s/%s" % (cs_path, elementName, elementType, statusType), status)

    res = csAPI.commitChanges()
    if not res['OK']:
      gLogger.warn('CS: %s' % res['Message'])

    return res

def updateCS( changeSet ):
  
  global vo, dry, ceBdiiDict
  
  changeList = list( changeSet )
  changeList.sort()
  if dry:
    gLogger.notice( 'The following needed changes are detected:\n' )
  else:  
    gLogger.notice( 'We are about to make the following changes to CS:\n' )
  for entry in changeList:
    gLogger.notice( "%s/%s %s -> %s" % entry )

  if not dry:
    csAPI = CSAPI()
    csAPI.initialize()
    result = csAPI.downloadCSData()
    if not result['OK']:
      gLogger.error( 'Failed to initialize CSAPI object', result['Message'] )
      DIRACExit( -1 )
    for section, option, value, new_value in changeSet:
      if value == 'Unknown' or not value:
        csAPI.setOption( cfgPath( section, option ), new_value )
      else:
        csAPI.modifyValue( cfgPath( section, option ), new_value )
        
    yn = raw_input( 'Do you want to commit changes to CS ? [default yes] [yes|no]: ' )
    if yn == '' or yn.lower().startswith( 'y' ):    
      result = csAPI.commit()
      if not result['OK']:
        gLogger.error( "Error while commit to CS", result['Message'] )
      else:
        gLogger.notice( "Successfully committed %d changes to CS" % len( changeSet ) )  

 def __init__(self):
     """initialise."""
     CSAPI.__init__(self)
     self._num_changes = 0
     self._append_dict = ConfigDefaultDict(list)
     self._append_unique_dict = ConfigDefaultDict(set)
     result = self.initialize()
     if not result['OK']:
         gLogger.error('Failed to initialise CSAPI object:',
                       result['Message'])
         raise RuntimeError(result['Message'])

  def beginExecution(self):
    """Reload the configurations before every cycle."""
    self.setup = self.am_getOption("Setup", self.setup)
    self.enabled = self.am_getOption("EnableFlag", self.enabled)
    self.restartAgents = self.am_getOption("RestartAgents", self.restartAgents)
    self.restartExecutors = self.am_getOption("RestartExecutors", self.restartExecutors)
    self.restartServices = self.am_getOption("RestartServices", self.restartServices)
    self.diracLocation = os.environ.get("DIRAC", self.diracLocation)
    self.addressTo = self.am_getOption('MailTo', self.addressTo)
    self.addressFrom = self.am_getOption('MailFrom', self.addressFrom)
    self.controlComponents = self.am_getOption('ControlComponents', self.controlComponents)
    self.commitURLs = self.am_getOption('CommitURLs', self.commitURLs)

    self.csAPI = CSAPI()

    res = self.getRunningInstances(instanceType='Agents')
    if not res["OK"]:
      return S_ERROR("Failure to get running agents")
    self.agents = res["Value"]

    res = self.getRunningInstances(instanceType='Executors')
    if not res["OK"]:
      return S_ERROR("Failure to get running executors")
    self.executors = res["Value"]

    res = self.getRunningInstances(instanceType='Services')
    if not res["OK"]:
      return S_ERROR("Failure to get running services")
    self.services = res["Value"]

    self.accounting.clear()
    return S_OK()

  def insertCSSection( self, path, pardict ):
    """ insert a section and values (or subsections) into the CS

    :param str path: full path of the new section
    :param str pardict: dictionary of key values in the new section, values can also be dictionaries
    :return: S_OK(), S_ERROR()
    """
    from DIRAC.ConfigurationSystem.Client.CSAPI import CSAPI
    if self.csapi is None:
      self.csapi = CSAPI()

    for key, value in pardict.iteritems():
      newSectionPath = os.path.join(path,key)
      gLogger.debug( "Adding to cs %s : %s " % ( newSectionPath, value ) )
      self.csapi.createSection( path )
      if isinstance( value, dict ):
        res = self.insertCSSection( newSectionPath, value )
      else:
        res = self.csapi.setOption( newSectionPath, value )

      if not res['OK']:
        return res
      else:
        gLogger.notice( "Added to CS: %s " % res['Value'] )

    return S_OK("Added all things to cs")

  def initialize( self ):

    # TODO: Have no default and if no mail is found then use the diracAdmin group
    # and resolve all associated mail addresses.
    self.addressTo = self.am_getOption( 'MailTo', self.addressTo )
    self.addressFrom = self.am_getOption( 'MailFrom', self.addressFrom )
    # create a list of alternative bdii urls
    self.alternativeBDIIs = self.am_getOption( 'AlternativeBDIIs', [] )
    # check if the bdii url is appended by a port number, if not append the default 2170
    for index, url in enumerate( self.alternativeBDIIs ):
      if not url.split( ':' )[-1].isdigit():
        self.alternativeBDIIs[index] += ':2170'
    if self.addressTo and self.addressFrom:
      self.log.info( "MailTo", self.addressTo )
      self.log.info( "MailFrom", self.addressFrom )
    if self.alternativeBDIIs :
      self.log.info( "AlternativeBDII URLs:", self.alternativeBDIIs )
    self.subject = "CE2CSAgent"

    # This sets the Default Proxy to used as that defined under
    # /Operations/Shifter/TestManager
    # the shifterProxy option in the Configuration can be used to change this default.
    self.am_setOption( 'shifterProxy', 'TestManager' )

    self.voName = self.am_getOption( 'VirtualOrganization', self.voName )
    if not self.voName:
      self.voName = getVO()

    if not self.voName:
      self.log.fatal( "VO option not defined for agent" )
      return S_ERROR()

    self.csAPI = CSAPI()
    return self.csAPI.initialize()

 def __init__( self, agentName, baseAgentName, properties ):
   AgentModule.__init__( self, agentName, baseAgentName, properties )
   self.addressTo = ''
   self.addressFrom = ''
   self.voName = ''
   self.csAPI = CSAPI()
   self.subject = "CE2CSAgent"
   self.alternativeBDIIs = []

  def initialize( self ):

    # client to connect to GOCDB
    self.GOCDBClient = GOCDBClient()

    # API needed to update configuration stored by CS
    self.csAPI = CSAPI()
    return self.csAPI.initialize()

class TestComponentInstallation(unittest.TestCase):
  """
  Contains methods for testing of separate elements
  """

  def setUp(self):
    self.host = 'localhost'
    self.notificationPort = 9154
    self.rootPwd = ''
    self.csClient = CSAPI()
    self.monitoringClient = ComponentMonitoringClient()
    self.client = SystemAdministratorClientCLI(self.host)

    self.csClient.downloadCSData()
    result = self.csClient.getCurrentCFG()
    if not result['OK']:
      raise Exception(result['Message'])
    cfg = result['Value']

    setup = cfg.getOption('DIRAC/Setup', 'dirac-JenkinsSetup')

    self.frameworkSetup = cfg.getOption('DIRAC/Setups/' + setup + '/Framework')
    self.rootPwd = cfg.getOption('Systems/Databases/Password')
    self.diracPwd = self.rootPwd

    result = getProxyInfo()
    if not result['OK']:
      raise Exception(result['Message'])
    chain = result['Value']['chain']
    result = chain.getCertInChain(-1)
    if not result['OK']:
      raise Exception(result['Message'])
    result = result['Value'].getSubjectDN()
    if not result['OK']:
      raise Exception(result['Message'])
    userDN = result['Value']
    result = getUsernameForDN(userDN)
    if not result['OK']:
      raise Exception(result['Message'])
    self.user = result['Value']
    if not self.user:
      self.user = 'unknown'

  def tearDown(self):
    pass

  def initialize(self):
    """ Run at the agent initialization (normally every 500 cycles)
    """
    # client to connect to GOCDB
    self.GOCDBClient = GOCDBClient()
    self.dryRun = self.am_getOption('DryRun', self.dryRun)

    # API needed to update configuration stored by CS
    self.csAPI = CSAPI()
    return self.csAPI.initialize()

  def __setCSStorageElementStatus( self, elementName, statusType, status ):
    """
    Sets on the CS the StorageElements status
    """

    statuses = self.rssConfig.getConfigStatusType( 'StorageElement' )
    if not statusType in statuses:
      gLogger.error( "%s is not a valid statusType" % statusType )
      return S_ERROR( "%s is not a valid statusType: %s" % ( statusType, statuses ) )

    csAPI = CSAPI()

    cs_path = "/Resources/StorageElements"

    csAPI.setOption( "%s/%s/%s" % ( cs_path, elementName, statusType ), status )

    res = csAPI.commitChanges()
    if not res[ 'OK' ]:
      gLogger.warn( 'CS: %s' % res[ 'Message' ] )

    return res

  def __init__( self ):
    """Internal initialization of the DIRAC Admin API.
    """
    super( DiracAdmin, self ).__init__()

    self.csAPI = CSAPI()

    self.dbg = False
    if gConfig.getValue( self.section + '/LogLevel', 'DEBUG' ) == 'DEBUG':
      self.dbg = True

    self.scratchDir = gConfig.getValue( self.section + '/ScratchDir', '/tmp' )
    self.currentDir = os.getcwd()

    def __init__(self):
        """Internal initialization of the DIRAC Admin API.
    """
        super(DiracAdmin, self).__init__()

        self.csAPI = CSAPI()

        self.dbg = False
        if gConfig.getValue(self.section + "/LogLevel", "DEBUG") == "DEBUG":
            self.dbg = True

        self.scratchDir = gConfig.getValue(self.section + "/ScratchDir", "/tmp")
        self.currentDir = os.getcwd()

  def __init__(self, vo, autoModifyUsers=True, autoAddUsers=True, autoDeleteUsers=False):

    self.log = gLogger.getSubLogger("VOMS2CSSynchronizer")
    self.csapi = CSAPI()
    self.vo = vo
    self.vomsVOName = getVOOption(vo, "VOMSName", "")
    if not self.vomsVOName:
      raise Exception("VOMS name not defined for VO %s" % vo)
    self.adminMsgs = {'Errors': [], 'Info': []}
    self.vomsUserDict = {}
    self.autoModifyUsers = autoModifyUsers
    self.autoAddUsers = autoAddUsers
    self.autoDeleteUsers = autoDeleteUsers