コード例 #1
0
def main():
  global force

  from DIRAC.FrameworkSystem.Client.ComponentInstaller import gComponentInstaller
  gComponentInstaller.exitOnError = True

  Script.registerSwitch("f", "force", "Forces the removal of the logs", setForce)
  Script.parseCommandLine()
  args = Script.getPositionalArgs()

  if len(args) == 1:
    args = args[0].split('/')

  if len(args) < 2:
    Script.showHelp(exitCode=1)

  system = args[0]
  component = args[1]

  monitoringClient = ComponentMonitoringClient()
  result = monitoringClient.getInstallations({'Instance': component, 'UnInstallationTime': None},
                                             {'System': system},
                                             {'HostName': socket.getfqdn()}, True)
  if not result['OK']:
    gLogger.error(result['Message'])
    DIRACexit(1)
  if len(result['Value']) < 1:
    gLogger.warn('Given component does not exist')
    DIRACexit(1)
  if len(result['Value']) > 1:
    gLogger.error('Too many components match')
    DIRACexit(1)

  removeLogs = False
  if force:
    removeLogs = True
  else:
    if result['Value'][0]['Component']['Type'] in gComponentInstaller.componentTypes:
      result = promptUser('Remove logs?', ['y', 'n'], 'n')
      if result['OK']:
        removeLogs = result['Value'] == 'y'
      else:
        gLogger.error(result['Message'])
        DIRACexit(1)

  result = gComponentInstaller.uninstallComponent(system, component, removeLogs)
  if not result['OK']:
    gLogger.error(result['Message'])
    DIRACexit(1)

  result = MonitoringUtilities.monitorUninstallation(system, component)
  if not result['OK']:
    gLogger.error(result['Message'])
    DIRACexit(1)
  gLogger.notice('Successfully uninstalled component %s/%s' % (system, component))
  DIRACexit()
コード例 #2
0
  def export_getHostInfo(self):
    """
    Retrieve host parameters
    """
    client = ComponentMonitoringClient()
    result = client.getLog(socket.getfqdn())

    if result['OK']:
      return S_OK(result['Value'][0])
    return self.__readHostInfo()
コード例 #3
0
 def getListOfHosts():
     """
 Return the list of all hosts that constitute a DIRAC instance
 """
     client = ComponentMonitoringClient()
     result = client.getHosts({}, False, False)
     if result['OK']:
         hosts = [host['HostName'] for host in result['Value']]
         return S_OK(hosts)
     return S_ERROR('Cannot get list of hosts: %s' % result['Message'])
コード例 #4
0
    def export_getHostInfo(self):
        """
    Retrieve host parameters
    """
        client = ComponentMonitoringClient()
        result = client.getLog(socket.getfqdn())

        if result['OK']:
            return S_OK(result['Value'][0])
        return self.__readHostInfo()
コード例 #5
0
    def manageService(self, service, action):
        """ Manage services running on this machine

      usage:

        service <action> <serviceName>
    """
        client = ComponentMonitoringClient()
        result = client.getInstallations({'UninstallationTime': None}, {
            'System': 'External',
            'Module': service,
            'Type': 'External'
        }, {'HostName': self.host}, False)
        if not result['OK']:
            self._errMsg(result['Message'])
            return
        elif len(result['Value']) < 1:
            self._errMsg('%s is not installed' % (service))
            return

        client = SystemAdministratorClient(self.host, self.port)
        if action == 'start':
            result = client.startService(service)
        elif action == 'stop':
            result = client.stopService(service)
        elif action == 'restart':
            result = client.restartService(service)
        elif action == 'status':
            result = client.statusService(service)

        if not result['OK']:
            self._errMsg(result['Message'])
            return

        gLogger.notice(result['Value'])
コード例 #6
0
def monitorUninstallation(system, component, cpu=None, hostname=None):
    """
  Register the uninstallation of a component in the ComponentMonitoringDB
  """
    monitoringClient = ComponentMonitoringClient()

    # Retrieve user uninstalling the component
    result = getProxyInfo()
    if result['OK']:
        user = result['Value']['username']
    else:
        return result
    if not user:
        user = '******'

    if not cpu:
        cpu = 'Not available'
        for line in open('/proc/cpuinfo'):
            if line.startswith('model name'):
                cpu = line.split(':')[1][0:64]
                cpu = cpu.replace('\n', '').lstrip().rstrip()

    if not hostname:
        hostname = socket.getfqdn()
    instance = component[0:32]

    result = monitoringClient.updateInstallations \
                          ( { 'Instance': instance, 'UnInstallationTime': None },
                            { 'System': system },
                            { 'HostName': hostname, 'CPU': cpu },
                            { 'UnInstallationTime': datetime.datetime.utcnow(),
                              'UnInstalledBy': user } )
    return result
コード例 #7
0
def monitorInstallation(componentType,
                        system,
                        component,
                        module=None,
                        cpu=None,
                        hostname=None):
    """
  Register the installation of a component in the ComponentMonitoringDB
  """
    monitoringClient = ComponentMonitoringClient()

    if not module:
        module = component

    # Retrieve user installing the component
    result = getProxyInfo()
    if result['OK']:
        user = result['Value']['username']
    else:
        return result
    if not user:
        user = '******'

    if not cpu:
        cpu = 'Not available'
        for line in open('/proc/cpuinfo'):
            if line.startswith('model name'):
                cpu = line.split(':')[1][0:64]
                cpu = cpu.replace('\n', '').lstrip().rstrip()

    if not hostname:
        hostname = socket.getfqdn()
    instance = component[0:32]

    result = monitoringClient.installationExists \
                          ( { 'Instance': instance,
                              'UnInstallationTime': None },
                            { 'Type': componentType,
                              'System': system,
                              'Module': module },
                            { 'HostName': hostname,
                              'CPU': cpu } )

    if not result['OK']:
        return result
    if result['Value']:
        return S_OK('Monitoring of %s is already enabled' % component)

    result = monitoringClient.addInstallation \
                              ( { 'InstallationTime': datetime.datetime.utcnow(),
                                  'InstalledBy': user,
                                  'Instance': instance },
                                { 'Type': componentType,
                                  'System': system,
                                  'Module': module },
                                { 'HostName': hostname,
                                  'CPU': cpu },
                                True )
    return result
コード例 #8
0
ファイル: MonitoringUtilities.py プロジェクト: TaykYoku/DIRAC
def monitorUninstallation(system, component, cpu=None, hostname=None):
    """
    Register the uninstallation of a component in the ComponentMonitoringDB
    """
    monitoringClient = ComponentMonitoringClient()

    # Retrieve user uninstalling the component
    user = None
    result = getProxyInfo()
    if result["OK"]:
        proxyInfo = result["Value"]
        if "username" in proxyInfo:
            user = proxyInfo["username"]
    else:
        return result
    if not user:
        user = "******"

    if not cpu:
        cpu = "Not available"
        for line in open("/proc/cpuinfo"):
            if line.startswith("model name"):
                cpu = line.split(":")[1][0:64]
                cpu = cpu.replace("\n", "").lstrip().rstrip()

    if not hostname:
        hostname = socket.getfqdn()
    instance = component[0:32]

    result = monitoringClient.updateInstallations(
        {
            "Instance": instance,
            "UnInstallationTime": None
        },
        {"DIRACSystem": system},
        {
            "HostName": hostname,
            "CPU": cpu
        },
        {
            "UnInstallationTime": datetime.datetime.utcnow(),
            "UnInstalledBy": user
        },
    )
    return result
コード例 #9
0
  def export_storeHostInfo( self ):
    """
    Retrieves and stores into a MySQL database information about the host
    """
    result = self.__readHostInfo()
    if not result[ 'OK' ]:
      gLogger.error( result[ 'Message' ] )
      return S_ERROR( result[ 'Message' ] )

    fields = result[ 'Value' ]
    fields[ 'Timestamp' ] = datetime.utcnow()
    client = ComponentMonitoringClient()
    result = client.updateLog( socket.getfqdn(), fields )
    if not result[ 'OK' ]:
      gLogger.error( result[ 'Message' ] )
      return S_ERROR( result[ 'Message' ] )

    return S_OK( 'Profiling information logged correctly' )
コード例 #10
0
    def __storeHostInfo():
        """
    Retrieves and stores into a MySQL database information about the host
    """
        result = SystemAdministratorHandler.__readHostInfo()
        if not result['OK']:
            gLogger.error(result['Message'])
            return result

        fields = result['Value']
        fields['Timestamp'] = datetime.utcnow()
        fields['Extension'] = fields['Extensions']
        client = ComponentMonitoringClient()
        result = client.updateLog(socket.getfqdn(), fields)
        if not result['OK']:
            gLogger.error(result['Message'])
            return result

        return S_OK('Profiling information logged correctly')
コード例 #11
0
  def __storeHostInfo():
    """
    Retrieves and stores into a MySQL database information about the host
    """
    result = SystemAdministratorHandler.__readHostInfo()
    if not result[ 'OK' ]:
      gLogger.error( result[ 'Message' ] )
      return result

    fields = result[ 'Value' ]
    fields[ 'Timestamp' ] = datetime.utcnow()
    fields[ 'Extension' ] = fields[ 'Extensions' ]
    client = ComponentMonitoringClient()
    result = client.updateLog( socket.getfqdn(), fields )
    if not result[ 'OK' ]:
      gLogger.error( result[ 'Message' ] )
      return result

    return S_OK( 'Profiling information logged correctly' )
コード例 #12
0
    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
コード例 #13
0
    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 = '******'
コード例 #14
0
    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 = "******"
コード例 #15
0
def monitorUninstallation( system, component, cpu = None, hostname = None ):
  """
  Register the uninstallation of a component in the ComponentMonitoringDB
  """
  monitoringClient = ComponentMonitoringClient()

  if not cpu:
    cpu = 'Not available'
    for line in open( '/proc/cpuinfo' ):
      if line.startswith( 'model name' ):
        cpu = line.split( ':' )[1][0:64]
        cpu = cpu.replace( '\n', '' ).lstrip().rstrip()

  if not hostname:
    hostname = socket.getfqdn()
  instance = component[ 0 : 32 ]

  result = monitoringClient.updateInstallations \
                        ( { 'Instance': instance, 'UnInstallationTime': None },
                          { 'System': system },
                          { 'HostName': hostname, 'CPU': cpu },
                          { 'UnInstallationTime': datetime.datetime.utcnow() } )
  return result
コード例 #16
0
  def getInstallations( self, argss ):
    """ Get data from the component monitoring database
    """
    display = 'table'
    installationFilter = {}
    componentFilter = {}
    hostFilter = {}

    key = None
    for arg in argss:
      if not key:
        if arg == 'list':
          display = 'list'
        elif arg == 'current':
          installationFilter[ 'UnInstallationTime' ] = None
        elif arg == '-t':
          key = 'Component.Type'
        elif arg == '-m':
          key = 'Component.Module'
        elif arg == '-s':
          key = 'Component.System'
        elif arg == '-h':
          key = 'Host.HostName'
        elif arg == '-n':
          key = 'Instance'
        elif arg == '-itb':
          key = 'InstallationTime.smaller'
        elif arg == '-ita':
          key = 'InstallationTime.bigger'
        elif arg == '-utb':
          key = 'UnInstallationTime.smaller'
        elif arg == '-uta':
          key = 'UnInstallationTime.bigger'
      else:
        if 'Component.' in key:
          componentFilter[ key.replace( 'Component.', '' ) ] = arg
        elif 'Host.' in key:
          hostFilter[ key.replace( 'Host.', '' ) ] = arg
        else:
          if 'Time.' in key:
            arg = datetime.datetime.strptime( arg, '%d-%m-%Y' )
          installationFilter[ key ] = arg
        key = None

    client = ComponentMonitoringClient()
    result = client.getInstallations( installationFilter, componentFilter, hostFilter, True )
    if not result[ 'OK' ]:
      self.__errMsg( 'Could not retrieve the installations: %s' % ( result[ 'Message' ] ) )
      installations = None
    else:
      installations = result[ 'Value' ]

    if installations:
      if display == 'table':
        gLogger.notice( '' )
        gLogger.notice( ' ' + 'Num'.center( 5 ) + ' ' \
                        + 'Host'.center( 20 ) + ' ' \
                        + 'Name'.center( 24 ) + ' ' \
                        + 'Module'.center( 24 ) + ' ' \
                        + 'System'.center( 20 ) + ' ' \
                        + 'Type'.center( 12 ) + ' ' \
                        + 'Installed on'.center( 18 ) + ' ' \
                        + 'Uninstalled on'.center( 18 ) + ' ' )
        gLogger.notice( ( '-' ) * 150 )
      for i, installation in enumerate( installations ):
        if installation[ 'UnInstallationTime' ]:
          uninstalledOn = installation[ 'UnInstallationTime' ].strftime( "%d-%m-%Y %H:%M" )
          isInstalled = 'No'
        else:
          uninstalledOn = ''
          isInstalled = 'Yes'

        if display == 'table':
          gLogger.notice( '|' + str( i + 1 ).center( 5 ) + '|' \
                          + installation[ 'Host' ][ 'HostName' ].center( 20 ) + '|' \
                          + installation[ 'Instance' ].center( 24 ) + '|' \
                          + installation[ 'Component' ][ 'Module' ].center( 24 ) + '|' \
                          + installation[ 'Component' ][ 'System' ].center( 20 ) + '|' \
                          + installation[ 'Component' ][ 'Type' ].center( 12 ) + '|' \
                          + installation[ 'InstallationTime' ].strftime( "%d-%m-%Y %H:%M" ).center( 18 ) + '|' \
                          + uninstalledOn.center( 18 ) + '|' )
          gLogger.notice( ( '-' ) * 150 )
        elif display == 'list':
          gLogger.notice( '' )
          gLogger.notice( 'Installation: '.rjust( 20 ) + str ( i + 1 ) )
          gLogger.notice( 'Installed: '.rjust( 20 ) + isInstalled )
          gLogger.notice( 'Host: '.rjust( 20 ) + installation[ 'Host' ][ 'HostName' ] )
          gLogger.notice( 'Name: '.rjust( 20 ) + installation[ 'Instance' ] )
          gLogger.notice( 'Module: '.rjust( 20 ) + installation[ 'Component' ][ 'Module' ] )
          gLogger.notice( 'System: '.rjust( 20 ) + installation[ 'Component' ][ 'System' ] )
          gLogger.notice( 'Type: '.rjust( 20 ) + installation[ 'Component' ][ 'Type' ] )
          gLogger.notice( 'Installed on: '.rjust( 20 ) + installation[ 'InstallationTime' ].strftime( "%d-%m-%Y %H:%M" ) )
          if uninstalledOn != '':
            gLogger.notice( 'Uninstalled on: '.rjust( 20 ) + uninstalledOn )
        else:
          self.__errMsg( 'No display mode was selected' )
      gLogger.notice( '' )
コード例 #17
0
def main():
    global hostName
    global hostDN
    global hostProperties
    Script.registerSwitch('H:', 'HostName:', 'Name of the Host (Mandatory)',
                          setHostName)
    Script.registerSwitch('D:', 'HostDN:',
                          'DN of the Host Certificate (Mandatory)', setHostDN)
    Script.registerSwitch(
        'P:', 'Property:',
        'Property to be added to the Host (Allow Multiple instances or None)',
        addProperty)

    Script.parseCommandLine(ignoreErrors=True)

    if hostName is None or hostDN is None:
        Script.showHelp(exitCode=1)

    args = Script.getPositionalArgs()

    from DIRAC.Interfaces.API.DiracAdmin import DiracAdmin
    diracAdmin = DiracAdmin()
    exitCode = 0
    errorList = []

    hostProps = {'DN': hostDN}
    if hostProperties:
        hostProps['Properties'] = ', '.join(hostProperties)

    for prop in args:
        pl = prop.split("=")
        if len(pl) < 2:
            errorList.append(
                ("in arguments",
                 "Property %s has to include a '=' to separate name from value"
                 % prop))
            exitCode = 255
        else:
            pName = pl[0]
            pValue = "=".join(pl[1:])
            Script.gLogger.info("Setting property %s to %s" % (pName, pValue))
            hostProps[pName] = pValue

    if not diracAdmin.csModifyHost(
            hostName, hostProps, createIfNonExistant=True)['OK']:
        errorList.append(("add host", "Cannot register host %s" % hostName))
        exitCode = 255
    else:
        result = diracAdmin.csCommitChanges()
        if not result['OK']:
            errorList.append(("commit", result['Message']))
            exitCode = 255

    if exitCode == 0:
        from DIRAC.FrameworkSystem.Client.ComponentMonitoringClient import ComponentMonitoringClient
        cmc = ComponentMonitoringClient()
        ret = cmc.hostExists(dict(HostName=hostName))
        if not ret['OK']:
            Script.gLogger.error(
                'Cannot check if host is registered in ComponentMonitoring',
                ret['Message'])
        elif ret['Value']:
            Script.gLogger.info(
                'Host already registered in ComponentMonitoring')
        else:
            ret = cmc.addHost(dict(HostName=hostName, CPU='TO_COME'))
            if not ret['OK']:
                Script.gLogger.error(
                    'Failed to add Host to ComponentMonitoring',
                    ret['Message'])

    for error in errorList:
        Script.gLogger.error("%s: %s" % error)

    DIRAC.exit(exitCode)
コード例 #18
0
                                    '  %s [option|cfgfile] ... System Component|System/Component' % Script.scriptName,
                                    'Arguments:',
                                    '  System:  Name of the DIRAC system (ie: WorkloadManagement)',
                                    '  Component: Name of the DIRAC component (ie: Matcher)'] ) )

Script.parseCommandLine()
args = Script.getPositionalArgs()

if len( args ) < 2:
  Script.showHelp()
  DIRACexit( 1 )

system = args[0]
component = args[1]

monitoringClient = ComponentMonitoringClient()
result = monitoringClient.getInstallations( { 'Instance': component, 'UnInstallationTime': None },
                                                  { 'System': system },
                                                  { 'HostName': socket.getfqdn() }, True )
if not result[ 'OK' ]:
  gLogger.error( result[ 'Message' ] )
  DIRACexit( 1 )
if len( result[ 'Value' ] ) < 1:
  gLogger.error( 'Given component does not exist' )
  DIRACexit( 1 )
if len( result[ 'Value' ] ) > 1:
  gLogger.error( 'Too many components match' )
  DIRACexit( 1 )

removeLogs = False
if force:
コード例 #19
0
def main():
    global excludedHosts
    Script.registerSwitch(
        "e:", "exclude=",
        "Comma separated list of hosts to be excluded from the scanning process",
        setExcludedHosts)
    Script.parseCommandLine(ignoreErrors=False)

    componentType = ""

    # Get my setup
    mySetup = gConfig.getValue("DIRAC/Setup")

    # Retrieve information from all the hosts
    client = SystemAdministratorIntegrator(exclude=excludedHosts)
    resultAll = client.getOverallStatus()
    if not resultAll["OK"]:
        gLogger.error(resultAll["Message"])
        DIRACexit(-1)

    # Retrieve user installing the component
    result = getProxyInfo()
    if result["OK"]:
        user = result["Value"]["username"]
    else:
        DIRACexit(-1)
    if not user:
        user = "******"

    for host in resultAll["Value"]:
        if not resultAll["Value"][host]["OK"]:
            # If the host cannot be contacted, exclude it and send message
            excludedHosts.append(host)

            result = NotificationClient().sendMail(
                Operations().getValue("EMail/Production", []),
                "Unreachable host",
                "\ndirac-populate-component-db: Could not fill the database with the components from unreachable host %s\n"
                % host,
            )
            if not result["OK"]:
                gLogger.error(
                    "Can not send unreachable host notification mail: %s" %
                    result["Message"])

    resultHosts = client.getHostInfo()
    if not resultHosts["OK"]:
        gLogger.error(resultHosts["Message"])
        DIRACexit(-1)
    resultInfo = client.getInfo()
    if not resultInfo["OK"]:
        gLogger.error(resultInfo["Message"])
        DIRACexit(-1)
    resultMySQL = client.getMySQLStatus()
    if not resultMySQL["OK"]:
        gLogger.error(resultMySQL["Message"])
        DIRACexit(-1)
    resultAllDB = client.getDatabases()
    if not resultAllDB["OK"]:
        gLogger.error(resultAllDB["Message"])
        DIRACexit(-1)
    resultAvailableDB = client.getAvailableDatabases()
    if not resultAvailableDB["OK"]:
        gLogger.error(resultAvailableDB["Message"])
        DIRACexit(-1)

    records = []
    finalSet = list(set(resultAll["Value"]) - set(excludedHosts))
    for host in finalSet:
        hasMySQL = True
        result = resultAll["Value"][host]
        hostResult = resultHosts["Value"][host]
        infoResult = resultInfo["Value"][host]
        mySQLResult = resultMySQL["Value"][host]
        allDBResult = resultAllDB["Value"][host]
        availableDBResult = resultAvailableDB["Value"][host]

        if not result["OK"]:
            gLogger.error("Host %s: %s" % (host, result["Message"]))
            continue
        if not hostResult["OK"]:
            gLogger.error("Host %s: %s" % (host, hostResult["Message"]))
            continue
        if not infoResult["OK"]:
            gLogger.error("Host %s: %s" % (host, infoResult["Message"]))
            continue
        if mySQLResult["OK"]:
            if not allDBResult["OK"]:
                gLogger.error("Host %s: %s" % (host, allDBResult["Message"]))
                continue
            if not availableDBResult["OK"]:
                gLogger.error("Host %s: %s" %
                              (host, availableDBResult["Message"]))
                continue
        else:
            hasMySQL = False

        setup = infoResult["Value"]["Setup"]
        if setup != mySetup:
            continue

        cpu = hostResult["Value"]["CPUModel"].strip()
        rDict = result["Value"]
        # Components other than databases
        for compType in rDict:
            if componentType and componentType != compType:
                continue
            for system in rDict[compType]:
                components = sorted(rDict[compType][system])
                for component in components:
                    record = {"Installation": {}, "Component": {}, "Host": {}}
                    if rDict[compType][system][component][
                            "Installed"] and component != "ComponentMonitoring":
                        runitStatus = str(
                            rDict[compType][system][component]["RunitStatus"])
                        if runitStatus != "Unknown":
                            module = str(
                                rDict[compType][system][component]["Module"])
                            record["Component"]["System"] = system
                            record["Component"]["Module"] = module
                            # Transform 'Services' into 'service', 'Agents' into 'agent' ...
                            record["Component"]["Type"] = compType.lower()[:-1]
                            record["Host"]["HostName"] = host
                            record["Host"]["CPU"] = cpu
                            record["Installation"]["Instance"] = component
                            record["Installation"][
                                "InstallationTime"] = datetime.utcnow()
                            record["Installation"]["InstalledBy"] = user
                            records.append(record)

        # Databases
        csClient = CSAPI()
        cfg = csClient.getCurrentCFG()["Value"]

        if hasMySQL:
            allDB = allDBResult["Value"]
            availableDB = availableDBResult["Value"]

            for db in allDB:
                # Check for DIRAC only databases
                if db in availableDB and db != "InstalledComponentsDB":
                    # Check for 'installed' databases
                    isSection = cfg.isSection(
                        "Systems/" + availableDB[db]["System"] + "/" +
                        cfg.getOption("DIRAC/Setups/" + setup + "/" +
                                      availableDB[db]["System"]) +
                        "/Databases/" + db + "/")
                    if isSection:
                        record = {
                            "Installation": {},
                            "Component": {},
                            "Host": {}
                        }
                        record["Component"]["System"] = availableDB[db][
                            "System"]
                        record["Component"]["Module"] = db
                        record["Component"]["Type"] = "DB"
                        record["Host"]["HostName"] = host
                        record["Host"]["CPU"] = cpu
                        record["Installation"]["Instance"] = db
                        record["Installation"][
                            "InstallationTime"] = datetime.utcnow()
                        record["Installation"]["InstalledBy"] = user
                        records.append(record)

    monitoringClient = ComponentMonitoringClient()

    # Add the installations to the database
    for record in records:
        result = MonitoringUtilities.monitorInstallation(
            record["Component"]["Type"],
            record["Component"]["System"],
            record["Installation"]["Instance"],
            record["Component"]["Module"],
            record["Host"]["CPU"],
            record["Host"]["HostName"],
        )
        if not result["OK"]:
            gLogger.error(result["Message"])
コード例 #20
0
  def getInstallations( self, argss ):
    """ Get data from the component monitoring database
    """
    display = 'table'
    installationFilter = {}
    componentFilter = {}
    hostFilter = {}

    key = None
    for arg in argss:
      if not key:
        if arg == 'list':
          display = 'list'
        elif arg == 'current':
          installationFilter[ 'UnInstallationTime' ] = None
        elif arg == '-t':
          key = 'Component.Type'
        elif arg == '-m':
          key = 'Component.Module'
        elif arg == '-s':
          key = 'Component.System'
        elif arg == '-h':
          key = 'Host.HostName'
        elif arg == '-n':
          key = 'Instance'
        elif arg == '-itb':
          key = 'InstallationTime.smaller'
        elif arg == '-ita':
          key = 'InstallationTime.bigger'
        elif arg == '-utb':
          key = 'UnInstallationTime.smaller'
        elif arg == '-uta':
          key = 'UnInstallationTime.bigger'
      else:
        if 'Component.' in key:
          componentFilter[ key.replace( 'Component.', '' ) ] = arg
        elif 'Host.' in key:
          hostFilter[ key.replace( 'Host.', '' ) ] = arg
        else:
          if 'Time.' in key:
            arg = datetime.datetime.strptime( arg, '%d-%m-%Y' )
          installationFilter[ key ] = arg
        key = None

    client = ComponentMonitoringClient()
    result = client.getInstallations( installationFilter, componentFilter, hostFilter, True )
    if not result[ 'OK' ]:
      self.__errMsg( 'Could not retrieve the installations: %s' % ( result[ 'Message' ] ) )
      installations = None
    else:
      installations = result[ 'Value' ]

    if installations:
      if display == 'table':
        gLogger.notice( '' )
        gLogger.notice( ' ' + 'Num'.center( 5 ) + ' ' \
                        + 'Host'.center( 20 ) + ' ' \
                        + 'Name'.center( 20 ) + ' ' \
                        + 'Module'.center( 20 ) + ' ' \
                        + 'System'.center( 16 ) + ' ' \
                        + 'Type'.center( 12 ) + ' ' \
                        + 'Installed on'.center( 18 ) + ' ' \
                        + 'Install by'.center( 12 ) + ' ' \
                        + 'Uninstalled on'.center( 18 ) + ' ' \
                        + 'Uninstall by'.center( 12 ) )
        gLogger.notice( ( '-' ) * 164 )
      for i, installation in enumerate( installations ):
        if not installation[ 'InstalledBy' ]:
          installedBy = ''
        else:
          installedBy = installation[ 'InstalledBy' ]

        if not installation[ 'UnInstalledBy' ]:
          uninstalledBy = ''
        else:
          uninstalledBy = installation[ 'UnInstalledBy' ]

        if installation[ 'UnInstallationTime' ]:
          uninstalledOn = installation[ 'UnInstallationTime' ].strftime( "%d-%m-%Y %H:%M" )
          isInstalled = 'No'
        else:
          uninstalledOn = ''
          isInstalled = 'Yes'

        if display == 'table':
          gLogger.notice( '|' + str( i + 1 ).center( 5 ) + '|' \
                          + installation[ 'Host' ][ 'HostName' ].center( 20 ) + '|' \
                          + installation[ 'Instance' ].center( 20 ) + '|' \
                          + installation[ 'Component' ][ 'Module' ].center( 20 ) + '|' \
                          + installation[ 'Component' ][ 'System' ].center( 16 ) + '|' \
                          + installation[ 'Component' ][ 'Type' ].center( 12 ) + '|' \
                          + installation[ 'InstallationTime' ].strftime( "%d-%m-%Y %H:%M" ).center( 18 ) + '|' \
                          + installedBy.center( 12 ) + '|' \
                          + uninstalledOn.center( 18 ) + '|' \
                          + uninstalledBy.center( 12 ) + '|' )
          gLogger.notice( ( '-' ) * 164 )
        elif display == 'list':
          gLogger.notice( '' )
          gLogger.notice( 'Installation: '.rjust( 20 ) + str ( i + 1 ) )
          gLogger.notice( 'Installed: '.rjust( 20 ) + isInstalled )
          gLogger.notice( 'Host: '.rjust( 20 ) + installation[ 'Host' ][ 'HostName' ] )
          gLogger.notice( 'Name: '.rjust( 20 ) + installation[ 'Instance' ] )
          gLogger.notice( 'Module: '.rjust( 20 ) + installation[ 'Component' ][ 'Module' ] )
          gLogger.notice( 'System: '.rjust( 20 ) + installation[ 'Component' ][ 'System' ] )
          gLogger.notice( 'Type: '.rjust( 20 ) + installation[ 'Component' ][ 'Type' ] )
          gLogger.notice( 'Installed on: '.rjust( 20 ) + installation[ 'InstallationTime' ].strftime( "%d-%m-%Y %H:%M" ) )
          if installedBy != '':
            gLogger.notice( 'Installed by: '.rjust( 20 ) + installedBy )
          if uninstalledOn != '':
            gLogger.notice( 'Uninstalled on: '.rjust( 20 ) + uninstalledOn )
            gLogger.notice( 'Uninstalled by: '.rjust( 20 ) + uninstalledBy )
        else:
          self.__errMsg( 'No display mode was selected' )
      gLogger.notice( '' )
コード例 #21
0
def main():
    global hostName
    global hostDN
    global hostProperties
    Script.registerSwitch("H:", "HostName:", "Name of the Host (Mandatory)",
                          setHostName)
    Script.registerSwitch("D:", "HostDN:",
                          "DN of the Host Certificate (Mandatory)", setHostDN)
    Script.registerSwitch(
        "P:", "Property:",
        "Property to be added to the Host (Allow Multiple instances or None)",
        addProperty)
    # Registering arguments will automatically add their description to the help menu
    Script.registerArgument([
        "Property=<Value>: Other properties to be added to the Host like (Responsible=XXX)"
    ],
                            mandatory=False)

    _, args = Script.parseCommandLine(ignoreErrors=True)

    if hostName is None or hostDN is None:
        Script.showHelp(exitCode=1)

    from DIRAC.Interfaces.API.DiracAdmin import DiracAdmin

    diracAdmin = DiracAdmin()
    exitCode = 0
    errorList = []

    hostProps = {"DN": hostDN}
    if hostProperties:
        hostProps["Properties"] = ", ".join(hostProperties)

    for prop in args:
        pl = prop.split("=")
        if len(pl) < 2:
            errorList.append(
                ("in arguments",
                 "Property %s has to include a '=' to separate name from value"
                 % prop))
            exitCode = 255
        else:
            pName = pl[0]
            pValue = "=".join(pl[1:])
            gLogger.info("Setting property %s to %s" % (pName, pValue))
            hostProps[pName] = pValue

    if not diracAdmin.csModifyHost(
            hostName, hostProps, createIfNonExistant=True)["OK"]:
        errorList.append(("add host", "Cannot register host %s" % hostName))
        exitCode = 255
    else:
        result = diracAdmin.csCommitChanges()
        if not result["OK"]:
            errorList.append(("commit", result["Message"]))
            exitCode = 255

    if exitCode == 0:
        from DIRAC.FrameworkSystem.Client.ComponentMonitoringClient import ComponentMonitoringClient

        cmc = ComponentMonitoringClient()
        ret = cmc.hostExists(dict(HostName=hostName))
        if not ret["OK"]:
            gLogger.error(
                "Cannot check if host is registered in ComponentMonitoring",
                ret["Message"])
        elif ret["Value"]:
            gLogger.info("Host already registered in ComponentMonitoring")
        else:
            ret = cmc.addHost(dict(HostName=hostName, CPU="TO_COME"))
            if not ret["OK"]:
                gLogger.error("Failed to add Host to ComponentMonitoring",
                              ret["Message"])

    for error in errorList:
        gLogger.error("%s: %s" % error)

    DIRAC.exit(exitCode)
コード例 #22
0
        Script.gLogger.info("Setting property %s to %s" % (pName, pValue))
        hostProps[pName] = pValue

if not diracAdmin.csModifyHost(hostName, hostProps,
                               createIfNonExistant=True)['OK']:
    errorList.append(("add host", "Cannot register host %s" % hostName))
    exitCode = 255
else:
    result = diracAdmin.csCommitChanges()
    if not result['OK']:
        errorList.append(("commit", result['Message']))
        exitCode = 255

if exitCode == 0:
    from DIRAC.FrameworkSystem.Client.ComponentMonitoringClient import ComponentMonitoringClient
    cmc = ComponentMonitoringClient()
    ret = cmc.hostExists(dict(HostName=hostName))
    if not ret['OK']:
        Script.gLogger.error(
            'Cannot check if host is registered in ComponentMonitoring',
            ret['Message'])
    elif ret['Value']:
        Script.gLogger.info('Host already registered in ComponentMonitoring')
    else:
        ret = cmc.addHost(dict(HostName=hostName, CPU='TO_COME'))
        if not ret['OK']:
            Script.gLogger.error('Failed to add Host to ComponentMonitoring',
                                 ret['Message'])

for error in errorList:
    Script.gLogger.error("%s: %s" % error)
コード例 #23
0
  def do_install( self, args ):
    """
        Install various DIRAC components

        usage:

          install mysql
          install db <database>
          install service <system> <service> [-m <ModuleName>] [-p <Option>=<Value>] [-p <Option>=<Value>] ...
          install agent <system> <agent> [-m <ModuleName>] [-p <Option>=<Value>] [-p <Option>=<Value>] ...
          install executor <system> <executor> [-m <ModuleName>] [-p <Option>=<Value>] [-p <Option>=<Value>] ...
    """
    argss = args.split()
    if not argss:
      gLogger.notice( self.do_install.__doc__ )
      return

    option = argss[0]
    del argss[0]
    if option == "mysql":
      gLogger.notice( "Installing MySQL database, this can take a while ..." )
      client = SystemAdministratorClient( self.host, self.port )
      if gComponentInstaller.mysqlPassword == 'LocalConfig':
        gComponentInstaller.mysqlPassword = ''
      gComponentInstaller.getMySQLPasswords()
      result = client.installMySQL( gComponentInstaller.mysqlRootPwd, gComponentInstaller.mysqlPassword )
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( "MySQL:", result['Value'] )
        gLogger.notice( "You might need to restart SystemAdministrator service to take new settings into account" )
    elif option == "db":
      if not argss:
        gLogger.notice( self.do_install.__doc__ )
        return
      database = argss[0]
      client = SystemAdministratorClient( self.host, self.port )

      result = client.getAvailableDatabases()
      if not result['OK']:
        self._errMsg( "Can not get database list: %s" % result['Message'] )
        return
      if not result['Value'].has_key( database ):
        self._errMsg( "Unknown database %s: " % database )
        return
      system = result['Value'][database]['System']
      setup = gConfig.getValue( '/DIRAC/Setup', '' )
      if not setup:
        self._errMsg( "Unknown current setup" )
        return
      instance = gConfig.getValue( '/DIRAC/Setups/%s/%s' % ( setup, system ), '' )
      if not instance:
        self._errMsg( "No instance defined for system %s" % system )
        self._errMsg( "\tAdd new instance with 'add instance %s <instance_name>'" % system )
        return

      if not gComponentInstaller.mysqlPassword:
        gComponentInstaller.mysqlPassword = '******'
      gComponentInstaller.getMySQLPasswords()
      result = client.installDatabase( database, gComponentInstaller.mysqlRootPwd )
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      extension, system = result['Value']

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return

      if database != 'InstalledComponentsDB':
        result = MonitoringUtilities.monitorInstallation( 'DB', system.replace( 'System', '' ), database, cpu = cpu, hostname = hostname )
        if not result['OK']:
          self._errMsg( result['Message'] )
          return
      # result = client.addDatabaseOptionsToCS( system, database )
      gComponentInstaller.mysqlHost = self.host
      result = client.getInfo()
      if not result['OK']:
        self._errMsg( result['Message'] )
      hostSetup = result['Value']['Setup']
      result = gComponentInstaller.addDatabaseOptionsToCS( gConfig, system, database, hostSetup, overwrite = True )
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      gLogger.notice( "Database %s from %s/%s installed successfully" % ( database, extension, system ) )
    elif option in self.runitComponents:
      if len( argss ) < 2:
        gLogger.notice( self.do_install.__doc__ )
        return

      system = argss[0]
      del argss[0]
      component = argss[0]
      del argss[0]

      specialOptions = {}
      module = ''
     
      for i in range(len(argss)):
        if argss[i] == "-m":
          specialOptions['Module'] = argss[i+1]
          module = argss[i+1]
        if argss[i] == "-p":
          opt,value = argss[i+1].split('=')
          specialOptions[opt] = value
      if module == component:
        module = ''

      client = SystemAdministratorClient( self.host, self.port )
      # First need to update the CS
      # result = client.addDefaultOptionsToCS( option, system, component )
      gComponentInstaller.host = self.host
      result = client.getInfo()
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      hostSetup = result['Value']['Setup']
    
      # Install Module section if not yet there
      if module:
        result = gComponentInstaller.addDefaultOptionsToCS( gConfig, option, system, module,
                                                            getCSExtensions(), hostSetup )
        # in case of Error we must stop, this can happen when the module name is wrong...
        if not result['OK']:
          self._errMsg( result['Message'] )
          return
        # Add component section with specific parameters only
        result = gComponentInstaller.addDefaultOptionsToCS( gConfig, option, system, component,
                                                            getCSExtensions(), hostSetup, specialOptions,
                                                            addDefaultOptions = True )
      else:
        # Install component section
        result = gComponentInstaller.addDefaultOptionsToCS( gConfig, option, system, component,
                                                            getCSExtensions(), hostSetup, specialOptions )

      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      # Then we can install and start the component
      result = client.setupComponent( option, system, component, module )
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      compType = result['Value']['ComponentType']
      runit = result['Value']['RunitStatus']
      gLogger.notice( "%s %s_%s is installed, runit status: %s" % ( compType, system, component, runit ) )

      # And register it in the database
      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      if component == 'ComponentMonitoring':
        # Make sure that the service is running before trying to use it
        nTries = 0
        maxTries = 5
        mClient = ComponentMonitoringClient()
        result = mClient.ping()
        while not result[ 'OK' ] and nTries < maxTries:
          time.sleep( 3 )
          result = mClient.ping()
          nTries = nTries + 1

        if not result[ 'OK' ]:
          self._errMsg( 'ComponentMonitoring service taking too long to start. Installation will not be logged into the database' )
          return

        result = MonitoringUtilities.monitorInstallation( 'DB', system, 'InstalledComponentsDB', cpu = cpu, hostname = hostname )
        if not result['OK']:
          self._errMsg( 'Error registering installation into database: %s' % result[ 'Message' ] )
          return
      
      result = MonitoringUtilities.monitorInstallation( option, system, component, module, cpu = cpu, hostname = hostname )
      if not result['OK']:
        self._errMsg( 'Error registering installation into database: %s' % result[ 'Message' ] )
        return
    else:
      gLogger.notice( "Unknown option:", option )
コード例 #24
0
def main():
    global force

    from DIRAC.FrameworkSystem.Client.ComponentInstaller import gComponentInstaller

    gComponentInstaller.exitOnError = True

    Script.registerSwitch("f", "force", "Forces the removal of the logs",
                          setForce)
    # Registering arguments will automatically add their description to the help menu
    Script.registerArgument((
        "System/Component: Full component name (ie: WorkloadManagement/Matcher)",
        "System:           Name of the DIRAC system (ie: WorkloadManagement)",
    ))
    Script.registerArgument(
        " Component:        Name of the DIRAC service (ie: Matcher)",
        mandatory=False)
    _, args = Script.parseCommandLine()

    if len(args) == 1:
        args = args[0].split("/")

    if len(args) < 2:
        Script.showHelp(exitCode=1)

    system = args[0]
    component = args[1]

    monitoringClient = ComponentMonitoringClient()
    result = monitoringClient.getInstallations(
        {
            "Instance": component,
            "UnInstallationTime": None
        }, {"System": system}, {"HostName": socket.getfqdn()}, True)
    if not result["OK"]:
        gLogger.error(result["Message"])
        DIRACexit(1)
    if len(result["Value"]) < 1:
        gLogger.warn("Given component does not exist")
        DIRACexit(1)
    if len(result["Value"]) > 1:
        gLogger.error("Too many components match")
        DIRACexit(1)

    removeLogs = False
    if force:
        removeLogs = True
    else:
        if result["Value"][0]["Component"][
                "Type"] in gComponentInstaller.componentTypes:
            result = promptUser("Remove logs?", ["y", "n"], "n")
            if result["OK"]:
                removeLogs = result["Value"] == "y"
            else:
                gLogger.error(result["Message"])
                DIRACexit(1)

    result = gComponentInstaller.uninstallComponent(system, component,
                                                    removeLogs)
    if not result["OK"]:
        gLogger.error(result["Message"])
        DIRACexit(1)

    result = MonitoringUtilities.monitorUninstallation(system, component)
    if not result["OK"]:
        gLogger.error(result["Message"])
        DIRACexit(1)
    gLogger.notice("Successfully uninstalled component %s/%s" %
                   (system, component))
    DIRACexit()
コード例 #25
0
  def do_uninstall( self, args ):
    """
        Uninstall DIRAC component

        usage:

          uninstall db <database>
          uninstall <-f ForceLogUninstall> <system> <component>
    """
    argss = args.split()
    if not argss:
      gLogger.notice( self.do_uninstall.__doc__ )
      return
    
    option = argss[0]
    if option == 'db':
      component = argss[1]
      client = SystemAdministratorClient( self.host, self.port )

      result = client.uninstallDatabase( component )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
      else:
        gLogger.notice( "Successfully uninstalled %s" % ( component ) )

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      result = client.getAvailableDatabases()
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      system = result[ 'Value' ][ component ][ 'System' ]
      result = MonitoringUtilities.monitorUninstallation( system , component, hostname = hostname, cpu = cpu )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
    else:
      if option == '-f':
        force = True
        del argss[0]
      else:
        force = False

      if len( argss ) != 2:
        gLogger.notice( self.do_uninstall.__doc__ )
        return

      system, component = argss
      client = SystemAdministratorClient( self.host, self.port )

      monitoringClient = ComponentMonitoringClient()
      result = monitoringClient.getInstallations( { 'Instance': component, 'UnInstallationTime': None },
                                                  { 'System': system },
                                                  { 'HostName': self.host }, True )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      if len( result[ 'Value' ] ) < 1:
        self.__errMsg( "Given component does not exist" )
        return
      if len( result[ 'Value' ] ) > 1:
        self.__errMsg( "Too many components match" )
        return

      removeLogs = False
      if force:
        removeLogs = True
      else:
        if result[ 'Value' ][0][ 'Component' ][ 'Type' ] in self.runitComponents:
          result = promptUser( 'Remove logs?', ['y', 'n'], 'n' )
          if result[ 'OK' ]:
            removeLogs = result[ 'Value' ] == 'y'

      result = client.uninstallComponent( system, component, removeLogs )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
      else:
        gLogger.notice( "Successfully uninstalled %s/%s" % ( system, component ) )

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      result = MonitoringUtilities.monitorUninstallation( system, component, hostname = hostname, cpu = cpu )
      if not result[ 'OK' ]:
        return result
コード例 #26
0
 def setUp( self ):
   """
   Initialize the client on every test
   """
   self.client = ComponentMonitoringClient()
コード例 #27
0
def main():
    global excludedHosts
    Script.registerSwitch(
        "e:", "exclude=",
        "Comma separated list of hosts to be excluded from the scanning process",
        setExcludedHosts)
    Script.parseCommandLine(ignoreErrors=False)

    componentType = ''

    # Get my setup
    mySetup = gConfig.getValue('DIRAC/Setup')

    # Retrieve information from all the hosts
    client = SystemAdministratorIntegrator(exclude=excludedHosts)
    resultAll = client.getOverallStatus()

    # Retrieve user installing the component
    result = getProxyInfo()
    if result['OK']:
        user = result['Value']['username']
    else:
        DIRACexit(-1)
    if not user:
        user = '******'

    notificationClient = NotificationClient()
    for host in resultAll['Value']:
        if not resultAll['Value'][host]['OK']:
            # If the host cannot be contacted, exclude it and send message
            excludedHosts.append(host)

            result = notificationClient.sendMail(
                Operations().getValue('EMail/Production',
                                      []), 'Unreachable host',
                '\ndirac-populate-component-db: Could not fill the database with the components from unreachable host %s\n'
                % host)
            if not result['OK']:
                gLogger.error(
                    'Can not send unreachable host notification mail: %s' %
                    result['Message'])

    if not resultAll['OK']:
        gLogger.error(resultAll['Message'])
        DIRACexit(-1)
    resultHosts = client.getHostInfo()
    if not resultHosts['OK']:
        gLogger.error(resultHosts['Message'])
        DIRACexit(-1)
    resultInfo = client.getInfo()
    if not resultInfo['OK']:
        gLogger.error(resultInfo['Message'])
        DIRACexit(-1)
    resultMySQL = client.getMySQLStatus()
    if not resultMySQL['OK']:
        gLogger.error(resultMySQL['Message'])
        DIRACexit(-1)
    resultAllDB = client.getDatabases()
    if not resultAllDB['OK']:
        gLogger.error(resultAllDB['Message'])
        DIRACexit(-1)
    resultAvailableDB = client.getAvailableDatabases()
    if not resultAvailableDB['OK']:
        gLogger.error(resultAvailableDB['Message'])
        DIRACexit(-1)

    records = []
    finalSet = list(set(resultAll['Value']) - set(excludedHosts))
    for host in finalSet:
        hasMySQL = True
        result = resultAll['Value'][host]
        hostResult = resultHosts['Value'][host]
        infoResult = resultInfo['Value'][host]
        mySQLResult = resultMySQL['Value'][host]
        allDBResult = resultAllDB['Value'][host]
        availableDBResult = resultAvailableDB['Value'][host]

        if not result['OK']:
            gLogger.error('Host %s: %s' % (host, result['Message']))
            continue
        if not hostResult['OK']:
            gLogger.error('Host %s: %s' % (host, hostResult['Message']))
            continue
        if not infoResult['OK']:
            gLogger.error('Host %s: %s' % (host, infoResult['Message']))
            continue
        if mySQLResult['OK']:
            if not allDBResult['OK']:
                gLogger.error('Host %s: %s' % (host, allDBResult['Message']))
                continue
            if not availableDBResult['OK']:
                gLogger.error('Host %s: %s' %
                              (host, availableDBResult['Message']))
                continue
        else:
            hasMySQL = False

        setup = infoResult['Value']['Setup']
        if setup != mySetup:
            continue

        cpu = hostResult['Value']['CPUModel'].strip()
        rDict = result['Value']
        # Components other than databases
        for compType in rDict:
            if componentType and componentType != compType:
                continue
            for system in rDict[compType]:
                components = sorted(rDict[compType][system])
                for component in components:
                    record = {'Installation': {}, 'Component': {}, 'Host': {}}
                    if rDict[compType][system][component]['Installed'] and \
                            component != 'ComponentMonitoring':
                        runitStatus = \
                            str(rDict[compType][system][component]['RunitStatus'])
                        if runitStatus != 'Unknown':
                            module = \
                                str(rDict[compType][system][component]['Module'])
                            record['Component']['System'] = system
                            record['Component']['Module'] = module
                            # Transform 'Services' into 'service', 'Agents' into 'agent' ...
                            record['Component']['Type'] = compType.lower()[:-1]
                            record['Host']['HostName'] = host
                            record['Host']['CPU'] = cpu
                            record['Installation']['Instance'] = component
                            record['Installation'][
                                'InstallationTime'] = datetime.utcnow()
                            record['Installation']['InstalledBy'] = user
                            records.append(record)

        # Databases
        csClient = CSAPI()
        cfg = csClient.getCurrentCFG()['Value']

        if hasMySQL:
            allDB = allDBResult['Value']
            availableDB = availableDBResult['Value']

            for db in allDB:
                # Check for DIRAC only databases
                if db in availableDB and db != 'InstalledComponentsDB':
                    # Check for 'installed' databases
                    isSection = cfg.isSection(
                        'Systems/' + availableDB[db]['System'] + '/' +
                        cfg.getOption('DIRAC/Setups/' + setup + '/' +
                                      availableDB[db]['System']) +
                        '/Databases/' + db + '/')
                    if isSection:
                        record = {
                            'Installation': {},
                            'Component': {},
                            'Host': {}
                        }
                        record['Component']['System'] = availableDB[db][
                            'System']
                        record['Component']['Module'] = db
                        record['Component']['Type'] = 'DB'
                        record['Host']['HostName'] = host
                        record['Host']['CPU'] = cpu
                        record['Installation']['Instance'] = db
                        record['Installation'][
                            'InstallationTime'] = datetime.utcnow()
                        record['Installation']['InstalledBy'] = user
                        records.append(record)

    monitoringClient = ComponentMonitoringClient()

    # Add the installations to the database
    for record in records:
        result = MonitoringUtilities.monitorInstallation(
            record['Component']['Type'], record['Component']['System'],
            record['Installation']['Instance'], record['Component']['Module'],
            record['Host']['CPU'], record['Host']['HostName'])
        if not result['OK']:
            gLogger.error(result['Message'])
コード例 #28
0
  def web_getSysInfo( self ):

    userData = self.getSessionData()

    DN = str( userData["user"]["DN"] )
    group = str( userData["user"]["group"] )

    callback = []


    # self.finish( { "success" : "false" , "error" : "No system information found" } )
    # return
    """
    client = SystemAdministratorIntegrator( delegatedDN = DN ,
                                          delegatedGroup = group )
    resultHosts = yield self.threadTask( client.getHostInfo )
    if resultHosts[ "OK" ]:
      hosts = resultHosts['Value']
      for i in hosts:
        if hosts[i]['OK']:
          host = hosts[i]['Value']
          host['Host'] = i
          callback.append( host )
        else:
          callback.append( {'Host':i} )
    else:
      self.finish( { "success" : "false" , "error" :  resultHosts['Message']} )
    """

    callback = []

    client = ComponentMonitoringClient()
    result = client.getHosts( {}, False, False )
    if result[ 'OK' ]:
      hosts = result[ 'Value' ]

      for obj in hosts:
        host = obj[ 'HostName' ]
        client = SystemAdministratorClient( host , None , delegatedDN = DN ,
                                            delegatedGroup = group )
        resultHost = yield self.threadTask( client.getHostInfo )
        if resultHost[ "OK" ]:
          resultHost[ "Value" ][ "Host" ] = host
          if "Timestamp" in resultHost[ "Value" ]:
            resultHost[ "Value" ][ "Timestamp" ] = str( resultHost[ "Value" ][ "Timestamp" ] )
          callback.append( resultHost[ "Value" ] )
        else:
          callback.append( { "Host":host } )

    total = len( callback )
    if not total > 0:
      self.finish( { "success" : "false" , "error" : "No system information found" } )
      return

    callback = sorted(callback, key=lambda i: i['Host'])

    # Add the information about the extensions' versions, if available, to display along with the DIRAC version
    for i in range( len( callback ) ):
      if 'Extension' in callback[ i ]:
        #We have to keep the backward compatibility (this can heppen when we do not update one host to v6r15 ...
        callback[ i ][ 'DIRAC' ] = '%s,%s' % ( callback[ i ].get( 'DIRACVersion', callback[ i ].get( 'DIRAC' ) ) , callback[ i ][ 'Extension' ] )
      elif 'Extensions' in callback[ i ]:
        callback[ i ][ 'DIRAC' ] = '%s,%s' % ( callback[ i ].get( 'DIRAC', callback[ i ].get( 'DIRAC' ) ) , callback[ i ][ 'Extensions' ] )

    self.finish( { "success" : "true" , "result" : callback , "total" : total } )
コード例 #29
0
  def do_uninstall( self, args ):
    """
        Uninstall DIRAC component

        usage:

          uninstall db <database>
          uninstall <-f ForceLogUninstall> <system> <component>
    """
    argss = args.split()
    if not argss:
      gLogger.notice( self.do_uninstall.__doc__ )
      return

    # Retrieve user uninstalling the component
    result = getProxyInfo()
    if not result[ 'OK' ]:
      self.__errMsg( result[ 'Message'] )
    user = result[ 'Value' ][ 'username' ]

    option = argss[0]
    if option == 'db':
      component = argss[1]
      client = SystemAdministratorClient( self.host, self.port )

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      result = client.getAvailableDatabases()
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      system = result[ 'Value' ][ component ][ 'System' ]
      result = MonitoringUtilities.monitorUninstallation( system , component, hostname = hostname, cpu = cpu )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return

      result = client.uninstallDatabase( component )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
      else:
        gLogger.notice( "Successfully uninstalled %s" % ( component ) )
    else:
      if option == '-f':
        force = True
        del argss[0]
      else:
        force = False

      if len( argss ) != 2:
        gLogger.notice( self.do_uninstall.__doc__ )
        return

      system, component = argss
      client = SystemAdministratorClient( self.host, self.port )

      monitoringClient = ComponentMonitoringClient()
      result = monitoringClient.getInstallations( { 'Instance': component, 'UnInstallationTime': None },
                                                  { 'System': system },
                                                  { 'HostName': self.host }, True )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      if len( result[ 'Value' ] ) < 1:
        self.__errMsg( "Given component does not exist" )
        return
      if len( result[ 'Value' ] ) > 1:
        self.__errMsg( "Too many components match" )
        return

      removeLogs = False
      if force:
        removeLogs = True
      else:
        if result[ 'Value' ][0][ 'Component' ][ 'Type' ] in self.runitComponents:
          result = promptUser( 'Remove logs?', ['y', 'n'], 'n' )
          if result[ 'OK' ]:
            removeLogs = result[ 'Value' ] == 'y'

      result = client.uninstallComponent( system, component, removeLogs )
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
      else:
        gLogger.notice( "Successfully uninstalled %s/%s" % ( system, component ) )

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self.__errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      result = MonitoringUtilities.monitorUninstallation( system, component, hostname = hostname, cpu = cpu )
      if not result[ 'OK' ]:
        return result
コード例 #30
0
  def do_uninstall( self, args ):
    """
        Uninstall a DIRAC component or host along with all its components

        usage:

          uninstall db <database>
          uninstall host <hostname>
          uninstall <-f ForceLogUninstall> <system> <component>
    """
    argss = args.split()
    if not argss:
      gLogger.notice( self.do_uninstall.__doc__ )
      return

    # Retrieve user uninstalling the component
    result = getProxyInfo()
    if not result[ 'OK' ]:
      self._errMsg( result[ 'Message'] )
    user = result[ 'Value' ][ 'username' ]

    option = argss[0]
    if option == 'db':
      del argss[0]
      if not argss:
        gLogger.notice( self.do_uninstall.__doc__ )
        return
      component = argss[0]
      client = SystemAdministratorClient( self.host, self.port )

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      result = client.getAvailableDatabases()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      system = result[ 'Value' ][ component ][ 'System' ]
      result = MonitoringUtilities.monitorUninstallation( system , component, hostname = hostname, cpu = cpu )
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return

      result = client.uninstallDatabase( component )
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
      else:
        gLogger.notice( "Successfully uninstalled %s" % ( component ) )
    elif option == 'host':
      del argss[0]
      if not argss:
        gLogger.notice( self.do_uninstall.__doc__ )
        return
      hostname = argss[0]

      client = ComponentMonitoringClient()
      result = client.hostExists( { 'HostName': hostname } )
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
      else:
        if not result[ 'Value' ]:
          self._errMsg( 'Given host does not exist' )
        else:
          result = client.getHosts( {'HostName': hostname }, True, False )
          if not result[ 'OK' ]:
            self._errMsg( result[ 'Message' ] )
          else:
            host = result[ 'Value' ][0]
            # Remove every installation associated with the host
            for installation in host[ 'Installations' ]:
              result = client.removeInstallations( installation, {}, { 'HostName': hostname } )
              if not result[ 'OK' ]:
                self._errMsg( result[ 'Message' ] )
                break
            # Finally remove the host
            result = client.removeHosts( { 'HostName': hostname } )
            if not result[ 'OK' ]:
              self._errMsg( result[ 'Message' ] )
            else:
              gLogger.notice( 'Host %s was successfully removed' % hostname )
    else:
      if option == '-f':
        force = True
        del argss[0]
      else:
        force = False

      if len( argss ) != 2:
        gLogger.notice( self.do_uninstall.__doc__ )
        return

      system, component = argss
      client = SystemAdministratorClient( self.host, self.port )

      monitoringClient = ComponentMonitoringClient()
      result = monitoringClient.getInstallations( { 'Instance': component, 'UnInstallationTime': None },
                                                  { 'System': system },
                                                  { 'HostName': self.host }, True )
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      if len( result[ 'Value' ] ) < 1:
        self._errMsg( "Given component does not exist" )
        return
      if len( result[ 'Value' ] ) > 1:
        self._errMsg( "Too many components match" )
        return

      removeLogs = False
      if force:
        removeLogs = True
      else:
        if result[ 'Value' ][0][ 'Component' ][ 'Type' ] in self.runitComponents:
          result = promptUser( 'Remove logs?', ['y', 'n'], 'n' )
          if result[ 'OK' ]:
            removeLogs = result[ 'Value' ] == 'y'

      result = client.uninstallComponent( system, component, removeLogs )
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
      else:
        gLogger.notice( "Successfully uninstalled %s/%s" % ( system, component ) )

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      result = MonitoringUtilities.monitorUninstallation( system, component, hostname = hostname, cpu = cpu )
      if not result[ 'OK' ]:
        return result
コード例 #31
0
    '  Component: Name of the DIRAC component (ie: Matcher)'
]))

Script.parseCommandLine()
args = Script.getPositionalArgs()

if len(args) == 1:
    args = args[0].split('/')

if len(args) < 2:
    Script.showHelp(exitCode=1)

system = args[0]
component = args[1]

monitoringClient = ComponentMonitoringClient()
result = monitoringClient.getInstallations(
    {
        'Instance': component,
        'UnInstallationTime': None
    }, {'System': system}, {'HostName': socket.getfqdn()}, True)
if not result['OK']:
    gLogger.error(result['Message'])
    DIRACexit(1)
if len(result['Value']) < 1:
    gLogger.warn('Given component does not exist')
    DIRACexit(1)
if len(result['Value']) > 1:
    gLogger.error('Too many components match')
    DIRACexit(1)
コード例 #32
0
ファイル: MonitoringUtilities.py プロジェクト: TaykYoku/DIRAC
def monitorInstallation(componentType,
                        system,
                        component,
                        module=None,
                        cpu=None,
                        hostname=None):
    """
    Register the installation of a component in the ComponentMonitoringDB
    """
    monitoringClient = ComponentMonitoringClient()

    if not module:
        module = component

    # Retrieve user installing the component
    user = None
    result = getProxyInfo()
    if result["OK"]:
        proxyInfo = result["Value"]
        if "username" in proxyInfo:
            user = proxyInfo["username"]
    else:
        return result
    if not user:
        user = "******"

    if not cpu:
        cpu = "Not available"
        for line in open("/proc/cpuinfo"):
            if line.startswith("model name"):
                cpu = line.split(":")[1][0:64]
                cpu = cpu.replace("\n", "").lstrip().rstrip()

    if not hostname:
        hostname = socket.getfqdn()
    instance = component[0:32]

    result = monitoringClient.installationExists(
        {
            "Instance": instance,
            "UnInstallationTime": None
        },
        {
            "Type": componentType,
            "DIRACSystem": system,
            "DIRACModule": module
        },
        {
            "HostName": hostname,
            "CPU": cpu
        },
    )

    if not result["OK"]:
        return result
    if result["Value"]:
        return S_OK("Monitoring of %s is already enabled" % component)

    result = monitoringClient.addInstallation(
        {
            "InstallationTime": datetime.datetime.utcnow(),
            "InstalledBy": user,
            "Instance": instance
        },
        {
            "Type": componentType,
            "DIRACSystem": system,
            "DIRACModule": module
        },
        {
            "HostName": hostname,
            "CPU": cpu
        },
        True,
    )
    return result
コード例 #33
0
  def do_install( self, args ):
    """
        Install various DIRAC components

        usage:

          install mysql
          install db <database>
          install service <system> <service> [-m <ModuleName>] [-p <Option>=<Value>] [-p <Option>=<Value>] ...
          install agent <system> <agent> [-m <ModuleName>] [-p <Option>=<Value>] [-p <Option>=<Value>] ...
          install executor <system> <executor> [-m <ModuleName>] [-p <Option>=<Value>] [-p <Option>=<Value>] ...
    """
    argss = args.split()
    if not argss:
      gLogger.notice( self.do_install.__doc__ )
      return

    option = argss[0]
    del argss[0]
    if option == "mysql":
      gLogger.notice( "Installing MySQL database, this can take a while ..." )
      client = SystemAdministratorClient( self.host, self.port )
      if gComponentInstaller.mysqlPassword == 'LocalConfig':
        gComponentInstaller.mysqlPassword = ''
      gComponentInstaller.getMySQLPasswords()
      result = client.installMySQL( gComponentInstaller.mysqlRootPwd, gComponentInstaller.mysqlPassword )
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( "MySQL:", result['Value'] )
        gLogger.notice( "You might need to restart SystemAdministrator service to take new settings into account" )
    elif option == "db":
      if not argss:
        gLogger.notice( self.do_install.__doc__ )
        return
      database = argss[0]
      client = SystemAdministratorClient( self.host, self.port )

      result = client.getAvailableDatabases()
      if not result['OK']:
        self._errMsg( "Can not get database list: %s" % result['Message'] )
        return
      if not result['Value'].has_key( database ):
        self._errMsg( "Unknown database %s: " % database )
        return
      system = result['Value'][database]['System']
      setup = gConfig.getValue( '/DIRAC/Setup', '' )
      if not setup:
        self._errMsg( "Unknown current setup" )
        return
      instance = gConfig.getValue( '/DIRAC/Setups/%s/%s' % ( setup, system ), '' )
      if not instance:
        self._errMsg( "No instance defined for system %s" % system )
        self._errMsg( "\tAdd new instance with 'add instance %s <instance_name>'" % system )
        return

      if not gComponentInstaller.mysqlPassword:
        gComponentInstaller.mysqlPassword = '******'
      gComponentInstaller.getMySQLPasswords()
      result = client.installDatabase( database, gComponentInstaller.mysqlRootPwd )
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      extension, system = result['Value']

      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return

      if database != 'InstalledComponentsDB':
        result = MonitoringUtilities.monitorInstallation( 'DB', system.replace( 'System', '' ), database, cpu = cpu, hostname = hostname )
        if not result['OK']:
          self._errMsg( result['Message'] )
          return
      # result = client.addDatabaseOptionsToCS( system, database )
      gComponentInstaller.mysqlHost = self.host
      result = client.getInfo()
      if not result['OK']:
        self._errMsg( result['Message'] )
      hostSetup = result['Value']['Setup']
      result = gComponentInstaller.addDatabaseOptionsToCS( gConfig, system, database, hostSetup, overwrite = True )
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      gLogger.notice( "Database %s from %s/%s installed successfully" % ( database, extension, system ) )
    elif option in self.runitComponents:
      if len( argss ) < 2:
        gLogger.notice( self.do_install.__doc__ )
        return

      system = argss[0]
      del argss[0]
      component = argss[0]
      del argss[0]

      specialOptions = {}
      module = ''
     
      for i in range(len(argss)):
        if argss[i] == "-m":
          specialOptions['Module'] = argss[i+1]
          module = argss[i+1]
        if argss[i] == "-p":
          opt,value = argss[i+1].split('=')
          specialOptions[opt] = value
      if module == component:
        module = ''

      client = SystemAdministratorClient( self.host, self.port )
      # First need to update the CS
      # result = client.addDefaultOptionsToCS( option, system, component )
      gComponentInstaller.host = self.host
      result = client.getInfo()
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      hostSetup = result['Value']['Setup']
    
      # Install Module section if not yet there
      if module:
        result = gComponentInstaller.addDefaultOptionsToCS( gConfig, option, system, module,
                                                            getCSExtensions(), hostSetup )
        # in case of Error we must stop, this can happen when the module name is wrong...
        if not result['OK']:
          self._errMsg( result['Message'] )
          return
        # Add component section with specific parameters only
        result = gComponentInstaller.addDefaultOptionsToCS( gConfig, option, system, component,
                                                            getCSExtensions(), hostSetup, specialOptions,
                                                            addDefaultOptions = True )
      else:
        # Install component section
        result = gComponentInstaller.addDefaultOptionsToCS( gConfig, option, system, component,
                                                            getCSExtensions(), hostSetup, specialOptions )

      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      # Then we can install and start the component
      result = client.setupComponent( option, system, component, module )
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      compType = result['Value']['ComponentType']
      runit = result['Value']['RunitStatus']
      gLogger.notice( "%s %s_%s is installed, runit status: %s" % ( compType, system, component, runit ) )

      # And register it in the database
      result = client.getHostInfo()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      else:
        cpu = result[ 'Value' ][ 'CPUModel' ]
      hostname = self.host
      if component == 'ComponentMonitoring':
        # Make sure that the service is running before trying to use it
        nTries = 0
        maxTries = 5
        mClient = ComponentMonitoringClient()
        result = mClient.ping()
        while not result[ 'OK' ] and nTries < maxTries:
          time.sleep( 3 )
          result = mClient.ping()
          nTries = nTries + 1

        if not result[ 'OK' ]:
          self._errMsg( 'ComponentMonitoring service taking too long to start. Installation will not be logged into the database' )
          return

        result = MonitoringUtilities.monitorInstallation( 'DB', system, 'InstalledComponentsDB', cpu = cpu, hostname = hostname )
        if not result['OK']:
          self._errMsg( 'Error registering installation into database: %s' % result[ 'Message' ] )
          return
      
      result = MonitoringUtilities.monitorInstallation( option, system, component, module, cpu = cpu, hostname = hostname )
      if not result['OK']:
        self._errMsg( 'Error registering installation into database: %s' % result[ 'Message' ] )
        return
    else:
      gLogger.notice( "Unknown option:", option )
コード例 #34
0
    def web_getSysInfo(self):

        userData = self.getSessionData()

        DN = str(userData["user"]["DN"])
        group = str(userData["user"]["group"])

        callback = []

        # self.finish( { "success" : "false" , "error" : "No system information found" } )
        # return
        """
    client = SystemAdministratorIntegrator( delegatedDN = DN ,
                                          delegatedGroup = group )
    resultHosts = yield self.threadTask( client.getHostInfo )
    if resultHosts[ "OK" ]:
      hosts = resultHosts['Value']
      for i in hosts:
        if hosts[i]['OK']:
          host = hosts[i]['Value']
          host['Host'] = i
          callback.append( host )
        else:
          callback.append( {'Host':i} )
    else:
      self.finish( { "success" : "false" , "error" :  resultHosts['Message']} )
    """

        callback = []

        client = ComponentMonitoringClient()
        result = client.getHosts({}, False, False)
        if result['OK']:
            hosts = result['Value']

            for obj in hosts:
                host = obj['HostName']
                client = SystemAdministratorClient(host,
                                                   None,
                                                   delegatedDN=DN,
                                                   delegatedGroup=group)
                resultHost = yield self.threadTask(client.getHostInfo)
                if resultHost["OK"]:
                    resultHost["Value"]["Host"] = host
                    if "Timestamp" in resultHost["Value"]:
                        resultHost["Value"]["Timestamp"] = str(
                            resultHost["Value"]["Timestamp"])
                    callback.append(resultHost["Value"])
                else:
                    callback.append({"Host": host})

        total = len(callback)
        if not total > 0:
            self.finish({
                "success": "false",
                "error": "No system information found"
            })
            return

        callback = sorted(callback, key=lambda i: i['Host'])

        # Add the information about the extensions' versions, if available, to display along with the DIRAC version
        for i in range(len(callback)):
            if 'Extension' in callback[i]:
                #We have to keep the backward compatibility (this can heppen when we do not update one host to v6r15 ...
                callback[i]['DIRAC'] = '%s,%s' % (callback[i].get(
                    'DIRACVersion',
                    callback[i].get('DIRAC')), callback[i]['Extension'])
            elif 'Extensions' in callback[i]:
                callback[i]['DIRAC'] = '%s,%s' % (callback[i].get(
                    'DIRAC',
                    callback[i].get('DIRAC')), callback[i]['Extensions'])

        self.finish({"success": "true", "result": callback, "total": total})
コード例 #35
0
        for db in allDB:
            # Check for DIRAC only databases
            if db in availableDB.keys() and db != 'InstalledComponentsDB':
                # Check for 'installed' databases
                isSection = cfg.isSection \
                              ( 'Systems/' + availableDB[ db ][ 'System' ] + '/' +
                                cfg.getOption( 'DIRAC/Setups/' + setup + '/' +
                                availableDB[ db ][ 'System' ] ) + '/Databases/' + db +
                               '/' )
                if isSection:
                    record = {'Installation': {}, 'Component': {}, 'Host': {}}
                    record['Component']['System'] = availableDB[db]['System']
                    record['Component']['Module'] = db
                    record['Component']['Type'] = 'DB'
                    record['Host']['HostName'] = host
                    record['Host']['CPU'] = cpu
                    record['Installation']['Instance'] = db
                    record['Installation'][
                        'InstallationTime'] = datetime.utcnow()
                    records.append(record)

monitoringClient = ComponentMonitoringClient()

# Add the installations to the database
for record in records:
    result = monitoringClient.addInstallation \
      ( record[ 'Installation' ], record[ 'Component' ], record[ 'Host' ], True )
    if not result['OK']:
        gLogger.error(result['Message'])
コード例 #36
0
  def do_show( self, args ):
    """
        Show list of components with various related information

        usage:

          show software      - show components for which software is available
          show installed     - show components installed in the host with runit system
          show setup         - show components set up for automatic running in the host
          show project       - show project to install or upgrade
          show status        - show status of the installed components
          show database      - show status of the databases
          show mysql         - show status of the MySQL server
          show log  <system> <service|agent> [nlines]
                             - show last <nlines> lines in the component log file
          show info          - show version of software and setup
          show doc <type> <system> <name>
                             - show documentation for a given service or agent
          show host          - show host related parameters
          show hosts         - show all available hosts
          show ports [host]  - show all ports used by a host. If no host is given, the host currently connected to is used
          show installations [ list | current | -n <Name> | -h <Host> | -s <System> | -m <Module> | -t <Type> | -itb <InstallationTime before>
                              | -ita <InstallationTime after> | -utb <UnInstallationTime before> | -uta <UnInstallationTime after> ]*
                             - show all the installations of components that match the given parameters
          show profile <system> <component> [ -s <size> | -h <host> | -id <initial date DD/MM/YYYY> | -it <initial time hh:mm>
                              | -ed <end date DD/MM/YYYY | -et <end time hh:mm> ]*
                             - show <size> log lines of profiling information for a component in the machine <host>
          show errors [*|<system> <service|agent>]
                             - show error count for the given component or all the components
                               in the last hour and day
    """

    argss = args.split()
    if not argss:
      gLogger.notice( self.do_show.__doc__ )
      return

    option = argss[0]
    del argss[0]

    if option == 'software':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getSoftwareComponents()
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        pprint.pprint( result['Value'] )
    elif option == 'installed':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getInstalledComponents()
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        pprint.pprint( result['Value'] )
    elif option == 'setup':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getSetupComponents()
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        pprint.pprint( result['Value'] )
    elif option == 'project':
      result = SystemAdministratorClient( self.host, self.port ).getProject()
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( "Current project is %s" % result[ 'Value' ] )
    elif option == 'status':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getOverallStatus()
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        fields = ["System",'Name','Module','Type','Setup','Installed','Runit','Uptime','PID']
        records = []
        rDict = result['Value']
        for compType in rDict:
          for system in rDict[compType]:
            components = rDict[compType][system].keys()
            components.sort()
            for component in components:
              record = []
              if rDict[compType][system][component]['Installed']:
                module = str( rDict[compType][system][component]['Module'] )
                record += [ system,component,module,compType.lower()[:-1]]
                if rDict[compType][system][component]['Setup']:
                  record += ['Setup']
                else:
                  record += ['NotSetup']
                if rDict[compType][system][component]['Installed']:
                  record += ['Installed']
                else:
                  record += ['NotInstalled']
                record += [str( rDict[compType][system][component]['RunitStatus'] )]
                record += [str( rDict[compType][system][component]['Timeup'] )]
                record += [str( rDict[compType][system][component]['PID'] )]
                records.append(record)
        printTable(fields,records)
    elif option == 'database' or option == 'databases':
      client = SystemAdministratorClient( self.host, self.port )
      if not gComponentInstaller.mysqlPassword:
        gComponentInstaller.mysqlPassword = "******"
      gComponentInstaller.getMySQLPasswords()
      result = client.getDatabases( gComponentInstaller.mysqlRootPwd )
      if not result['OK']:
        self._errMsg( result['Message'] )
        return
      resultSW = client.getAvailableDatabases()
      if not resultSW['OK']:
        self._errMsg( resultSW['Message'] )
        return

      sw = resultSW['Value']
      installed = result['Value']
      gLogger.notice( '' )
      for db in sw:
        if db in installed:
          gLogger.notice( db.rjust( 25 ), ': Installed' )
        else:
          gLogger.notice( db.rjust( 25 ), ': Not installed' )
      if not sw:
        gLogger.notice( "No database found" )
    elif option == 'mysql':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getMySQLStatus()
      if not result['OK']:
        self._errMsg( result['Message'] )
      elif result['Value']:
        gLogger.notice( '' )
        for par, value in result['Value'].items():
          gLogger.notice( ( par.rjust( 28 ), ':', value ) )
      else:
        gLogger.notice( "No MySQL database found" )
    elif option == "log":
      self.getLog( argss )
    elif option == "info":
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getInfo()
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        gLogger.notice( "Setup:", result['Value']['Setup'] )
        gLogger.notice( "DIRAC version:", result['Value']['DIRAC'] )
        if result['Value']['Extensions']:
          for e, v in result['Value']['Extensions'].items():
            gLogger.notice( "%s version" % e, v )
        gLogger.notice( '' )
    elif option == "host":
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getHostInfo()
      if not result['OK']:
        self._errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        gLogger.notice( "Host info:" )
        gLogger.notice( '' )

        fields = ['Parameter','Value']
        records = []
        for parameter in result['Value'].iteritems():
          if parameter[0] == 'Extension':
            extensions = parameter[1].split( ',' )
            for extension in extensions:
              extensionName, extensionVersion = extension.split( ':' )
              records.append( [ '%sVersion' % extensionName, str( extensionVersion ) ] )
          else:
            records.append( [ parameter[0], str( parameter[1] ) ] )

        printTable( fields, records )
    elif option == "hosts":
      client = ComponentMonitoringClient()
      result = client.getHosts( {}, False, False )
      if not result[ 'OK' ]:
        self._errMsg( 'Error retrieving the list of hosts: %s' % ( result[ 'Message' ] ) )
      else:
        hostList = result[ 'Value' ]
        gLogger.notice( '' )
        gLogger.notice( ' ' + 'Host'.center( 32 ) + ' ' + 'CPU'.center( 34 ) + ' ' )
        gLogger.notice( ( '-' * 69 ) )
        for element in hostList:
          gLogger.notice( '|' + element[ 'HostName' ].center( 32 ) + '|' + element[ 'CPU' ].center( 34 ) + '|' )
        gLogger.notice( ( '-' * 69 ) )
        gLogger.notice( '' )
    elif option == "ports":
      if not argss:
        client = SystemAdministratorClient( self.host )
      else:
        hostname = argss[0]
        del argss[0]

        client = ComponentMonitoringClient()
        result = client.hostExists( { 'HostName': hostname } )
        if not result[ 'OK' ]:
          self._errMsg( result[ 'Message' ] )
          return
        else:
          if not result[ 'Value' ]:
            self._errMsg( 'Given host does not exist' )
            return

        client = SystemAdministratorClient( hostname )

      result = client.getUsedPorts()
      if not result[ 'OK' ]:
        self._errMsg( result[ 'Message' ] )
        return
      pprint.pprint( result[ 'Value' ] )
    elif option == "errors":
      self.getErrors( argss )
    elif option == "installations":
      self.getInstallations( argss )
    elif option == "doc":
      if len( argss ) > 2:
        if argss[0] in [ 'service', 'agent' ]:
          compType = argss[0]
          compSystem = argss[1]
          compModule = argss[2]
          client = SystemAdministratorClient( self.host, self.port )
          result = client.getComponentDocumentation( compType, compSystem, compModule )
          if result[ 'OK' ]:
            gLogger.notice( result[ 'Value' ] )
          else:
            self._errMsg( result[ 'Message' ] )
        else:
          gLogger.notice( self.do_show.__doc__ )
      else:
        gLogger.notice( self.do_show.__doc__ )
    elif option == "profile":
      if len( argss ) > 1:
        system = argss[0]
        del argss[0]
        component = argss[0]
        del argss[0]

        component = '%s_%s' % ( system, component )

        argDict = { '-s': None, '-h': self.host, '-id': None, '-it': '00:00', '-ed': None, '-et': '00:00' }
        key = None
        for arg in argss:
          if not key:
            key = arg
          else:
            argDict[ key ] = arg
            key = None

        size = None
        try:
          if argDict[ '-s' ]:
            size = int( argDict[ '-s' ] )
        except ValueError as _ve:
          self._errMsg( 'Argument \'size\' must be an integer' )
          return
        host = argDict[ '-h' ]
        initialDate = argDict[ '-id' ]
        initialTime = argDict[ '-it' ]
        endingDate = argDict[ '-ed' ]
        endingTime = argDict[ '-et' ]

        if initialDate:
          initialDate = '%s %s' % ( initialDate, initialTime )
        else:
          initialDate = ''
        if endingDate:
          endingDate = '%s %s' % ( endingDate, endingTime )
        else:
          endingDate = ''

        client = MonitoringClient()
        if size:
          result = client.getLimitedData( host, component, size )
        else:
          result = client.getDataForAGivenPeriod( host, component, initialDate, endingDate )

        if result[ 'OK' ]:
          text = ''
          headers = [result['Value'][0].keys()]
          for header in headers:
            text += str( header ).ljust( 15 )
          gLogger.notice( text )
          for record in result[ 'Value' ]:
            for metric in record.itervalues():
              text += str( metric ).ljust( 15 )
            gLogger.notice( text )
        else:
          self._errMsg( result[ 'Message' ] )
      else:
        gLogger.notice( self.do_show.__doc__ )
    else:
      gLogger.notice( "Unknown option:", option )
コード例 #37
0
Script.setUsageMessage('\n'.join([
    __doc__.split('\n')[1], 'Usage:',
    '  %s [option|cfgfile] ... [debug]' % Script.scriptName
]))

Script.parseCommandLine(ignoreErrors=False)
args = Script.getPositionalArgs()

services = ['vcycle', 'squid']
componentType = ''

# Get my setup
mySetup = gConfig.getValue('DIRAC/Setup')

monitoringClient = ComponentMonitoringClient()

# Retrieve information from all the hosts
client = SystemAdministratorIntegrator(exclude=excludedHosts)
resultAll = client.getOverallStatus()

notificationClient = NotificationClient()
for host in resultAll['Value']:
    if not resultAll['Value'][host]['OK']:
        # If the host cannot be contacted, exclude it and send message
        excludedHosts.append(host)

        result = notificationClient.sendMail(
            Operations().getValue('EMail/Production', []), 'Unreachable host',
            '\ndirac-populate-component-db: Could not fill the database with the components from unreachable host %s\n'
            % host)
コード例 #38
0
  def do_show( self, args ):
    """
        Show list of components with various related information

        usage:

          show software      - show components for which software is available
          show installed     - show components installed in the host with runit system
          show setup         - show components set up for automatic running in the host
          show project       - show project to install or upgrade
          show status        - show status of the installed components
          show database      - show status of the databases
          show mysql         - show status of the MySQL server
          show log  <system> <service|agent> [nlines]
                             - show last <nlines> lines in the component log file
          show info          - show version of software and setup
          show host          - show host related parameters
          show hosts         - show all available hosts
          show installations [ list | current | -n <Name> | -h <Host> | -s <System> | -m <Module> | -t <Type> | -itb <InstallationTime before>
                              | -ita <InstallationTime after> | -utb <UnInstallationTime before> | -uta <UnInstallationTime after> ]*
                             - show all the installations of components that match the given parameters
          show errors [*|<system> <service|agent>]
                             - show error count for the given component or all the components
                               in the last hour and day
    """

    argss = args.split()
    if not argss:
      gLogger.notice( self.do_show.__doc__ )
      return

    option = argss[0]
    del argss[0]

    if option == 'software':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getSoftwareComponents()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        pprint.pprint( result['Value'] )
    elif option == 'installed':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getInstalledComponents()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        pprint.pprint( result['Value'] )
    elif option == 'setup':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getSetupComponents()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        pprint.pprint( result['Value'] )
    elif option == 'project':
      result = SystemAdministratorClient( self.host, self.port ).getProject()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      else:
        gLogger.notice( "Current project is %s" % result[ 'Value' ] )
    elif option == 'status':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getOverallStatus()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      else:
        fields = ["System",'Name','Module','Type','Setup','Installed','Runit','Uptime','PID']
        records = []
        rDict = result['Value']
        for compType in rDict:
          for system in rDict[compType]:
            components = rDict[compType][system].keys()
            components.sort()
            for component in components:
              record = []
              if rDict[compType][system][component]['Installed']:
                module = str( rDict[compType][system][component]['Module'] )
                record += [ system,component,module,compType.lower()[:-1]]
                if rDict[compType][system][component]['Setup']:
                  record += ['Setup']
                else:
                  record += ['NotSetup']
                if rDict[compType][system][component]['Installed']:
                  record += ['Installed']
                else:
                  record += ['NotInstalled']
                record += [str( rDict[compType][system][component]['RunitStatus'] )]
                record += [str( rDict[compType][system][component]['Timeup'] )]
                record += [str( rDict[compType][system][component]['PID'] )]
                records.append(record)  
        printTable(fields,records)        
    elif option == 'database' or option == 'databases':
      client = SystemAdministratorClient( self.host, self.port )
      if not InstallTools.mysqlPassword:
        InstallTools.mysqlPassword = "******"
      InstallTools.getMySQLPasswords()
      result = client.getDatabases( InstallTools.mysqlRootPwd )
      if not result['OK']:
        self.__errMsg( result['Message'] )
        return
      resultSW = client.getAvailableDatabases()
      if not resultSW['OK']:
        self.__errMsg( resultSW['Message'] )
        return

      sw = resultSW['Value']
      installed = result['Value']
      gLogger.notice( '' )
      for db in sw:
        if db in installed:
          gLogger.notice( db.rjust( 25 ), ': Installed' )
        else:
          gLogger.notice( db.rjust( 25 ), ': Not installed' )
      if not sw:
        gLogger.notice( "No database found" )
    elif option == 'mysql':
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getMySQLStatus()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      elif result['Value']:
        gLogger.notice( '' )
        for par, value in result['Value'].items():
          gLogger.notice( ( par.rjust( 28 ), ':', value ) )
      else:
        gLogger.notice( "No MySQL database found" )
    elif option == "log":
      self.getLog( argss )
    elif option == "info":
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getInfo()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      else:
        gLogger.notice( '' )
        gLogger.notice( "Setup:", result['Value']['Setup'] )
        gLogger.notice( "DIRAC version:", result['Value']['DIRAC'] )
        if result['Value']['Extensions']:
          for e, v in result['Value']['Extensions'].items():
            gLogger.notice( "%s version" % e, v )
        gLogger.notice( '' )
    elif option == "host":
      client = SystemAdministratorClient( self.host, self.port )
      result = client.getHostInfo()
      if not result['OK']:
        self.__errMsg( result['Message'] )
      else:   
        gLogger.notice( '' )
        gLogger.notice( "Host info:" )
        gLogger.notice( '' )
        
        fields = ['Parameter','Value']
        records = []
        for key, value in result['Value'].items():
          records.append( [key, str( value ) ] )
          
        printTable( fields, records )  
    elif option == "hosts":
      client = ComponentMonitoringClient()
      result = client.getHosts( {}, False, False )
      if not result[ 'OK' ]:
        self.__errMsg( 'Error retrieving the list of hosts: %s' % ( result[ 'Message' ] ) )
      else:
        hostList = result[ 'Value' ]
        gLogger.notice( '' )
        gLogger.notice( ' ' + 'Host'.center( 32 ) + ' ' + 'CPU'.center( 34 ) + ' ' )
        gLogger.notice( ( '-' * 69 ) )
        for element in hostList:
          gLogger.notice( '|' + element[ 'HostName' ].center( 32 ) + '|' + element[ 'CPU' ].center( 34 ) + '|' )
        gLogger.notice( ( '-' * 69 ) )
        gLogger.notice( '' )
    elif option == "errors":
      self.getErrors( argss )
    elif option == "installations":
      self.getInstallations( argss )
    else:
      gLogger.notice( "Unknown option:", option )