Exemplo n.º 1
0
def _reportSystem(sapUtils, system, domain, isSolMan, tmsDomain):
    '@types: SapUtils, System, str, bool, sap.TmsDomain -> osh'
    sapReporter = sap.Reporter(sap.Builder())
    userName = fptools.safeFunc(sapUtils.getUserName)()
    credentialsId = fptools.safeFunc(sapUtils.getCredentialId)()
    systemOsh = sapReporter.reportSystemPdo(sap.Builder.SystemPdo(
        system, ipAddress=sapUtils.getIpAddress(), ipDomain=domain,
        username=userName, credentialsId=credentialsId,
        connectionClient=sapUtils.getConnectionClient(),
        router=sapUtils.getRouter(), isSolutionManager=isSolMan,
        tmsDomain=tmsDomain))
    return systemOsh
Exemplo n.º 2
0
def get_remote_databases(executor,
                         shell_interpreter,
                         instance_name,
                         db2_home_path=None):
    r'''@types: command.CmdExecutor, shell_interpreter.Interpreter, unicode,
                file_topology.Path -> list(db2_model.Database)
        @raise ExecuteError: on DB2INSTANCE variable setting failure
        @raise command.ExecuteException: on db2 cmdb execution failure
    '''
    db2cmd = __get_configured_db2_cmd(shell_interpreter, instance_name,
                                      db2_home_path)
    list_db_directory = db2cmd.list_db_directory()
    dcs_entries = fptools.safeFunc(executor)(db2cmd.list_dcs_directory()) or ()

    lt_names = ((e.local_dbname, e.target_dbname) for e in dcs_entries)

    is_remote = fptools.comp(partial(operator.eq, DatabaseEntryTypes.REMOTE),
                             Db2.DatabaseEntry.entry_type.fget)
    remote_db_entries = list_db_directory | executor
    remote_db_entries = ifilter(is_remote, remote_db_entries)

    resolve_db_name = partial(_resolve_remotedb_name, dict(lt_names))
    remote_db_entries = imap(resolve_db_name, remote_db_entries)

    get_nodename = Db2.DatabaseEntry.node_name.fget
    dbs_by_nodename = fptools.groupby(get_nodename, remote_db_entries)

    get_dbname = Db2.DatabaseEntry.name.fget
    node_map_pairs = [(node, fptools.groupby(get_dbname, db_entries))
                      for node, db_entries in dbs_by_nodename.iteritems()]

    return _parse_remote_databases(node_map_pairs)
def get_version_by_instance_name(shell, instance_name):
    discover_version = partial(fptools.safeFunc(__version_by_instance_name),
                               shell, instance_name)
    return fptools.findFirst(lambda x: x,
                                ifilter(None, imap(discover_version,
                                                   registry.get_discoverers()))
                             )
Exemplo n.º 4
0
    def parseDatabases(self, doc):
        'r@types: org.w3c.dom.Document -> list(JEEDiscovererByHTTP.DbInstance)'
        dbInstanceNodes = self._evalToNodes('/SAP_J2EE/DB_INSTANCE', doc)

        buildDbInstanceSafely = fptools.safeFunc(self._parseDbInstance)
        res = map(buildDbInstanceSafely, dbInstanceNodes)
        return filter(None, res)
Exemplo n.º 5
0
def get_db2_version_by_home_path(reg_provider, db2_home_path):
    regbased_discoverers = registry.get_discoverers()
    discover_version = Fn(fptools.safeFunc(__discover_version),
                         reg_provider, fptools._, db2_home_path)
    return fptools.findFirst(lambda x: x,
                                ifilter(None, imap(discover_version,
                                                   regbased_discoverers)))
def get_remote_databases(executor, shell_interpreter, instance_name, db2_home_path=None):
    r"""@types: command.CmdExecutor, shell_interpreter.Interpreter, unicode,
                file_topology.Path -> list(db2_model.Database)
        @raise ExecuteError: on DB2INSTANCE variable setting failure
        @raise command.ExecuteException: on db2 cmdb execution failure
    """
    db2cmd = __get_configured_db2_cmd(shell_interpreter, instance_name, db2_home_path)
    list_db_directory = db2cmd.list_db_directory()
    dcs_entries = fptools.safeFunc(executor)(db2cmd.list_dcs_directory()) or ()

    lt_names = ((e.local_dbname, e.target_dbname) for e in dcs_entries)

    is_remote = fptools.comp(partial(operator.eq, DatabaseEntryTypes.REMOTE), Db2.DatabaseEntry.entry_type.fget)
    remote_db_entries = list_db_directory | executor
    remote_db_entries = ifilter(is_remote, remote_db_entries)

    resolve_db_name = partial(_resolve_remotedb_name, dict(lt_names))
    remote_db_entries = imap(resolve_db_name, remote_db_entries)

    get_nodename = Db2.DatabaseEntry.node_name.fget
    dbs_by_nodename = fptools.groupby(get_nodename, remote_db_entries)

    get_dbname = Db2.DatabaseEntry.name.fget
    node_map_pairs = [
        (node, fptools.groupby(get_dbname, db_entries)) for node, db_entries in dbs_by_nodename.iteritems()
    ]

    return _parse_remote_databases(node_map_pairs)
Exemplo n.º 7
0
    def parseCentralServices(self, doc):
        'r@types:org.w3c.dom.Document -> list(JEEDiscovererByHTTP.ScsInstance)'
        scsInstanceNodes = self._evalToNodes('/SAP_J2EE/SCS_INSTANCE', doc)

        buildScsInstanceSafely = fptools.safeFunc(self._parseScsInstance)
        res = map(buildScsInstanceSafely, scsInstanceNodes)
        return filter(None, res)
Exemplo n.º 8
0
 def _parseOutput(self, ipconfigBuffer, langBund):
     r'@types: str, ResourceBundle -> list[ip_addr._BaseIP]'
     keyword = langBund.getString('windows_ipconfig_str_dnsservers').strip()
     inDns = 0
     # order of added IPs is important so we do not use set and just check
     # for already added IPs
     ips = []
     parseIp = fptools.safeFunc(self.__parseIpInLine)
     if ipconfigBuffer:
         for line in ipconfigBuffer.splitlines():
             if (line.find(keyword) != -1):
                 inDns = 1
                 ip = parseIp(line)
                 if ip and not ip in ips and ip_addr.isValidIpAddressNotZero(
                         ip):
                     ips.append(ip)
                 continue
             if (inDns == 1):
                 if (line.find('. :') == -1):
                     ip = parseIp(line)
                     if ip and not ip in ips and ip_addr.isValidIpAddressNotZero(
                             ip):
                         ips.append(ip)
                 else:
                     inDns = 0
     return ips
Exemplo n.º 9
0
 def getHostNodes(self):
     r'''@types: -> list[HostNode]
     @raise TrexTopologyConfig.NodeNotFound:
     '''
     rootHostNode = getUnderlyingNodeByName(self.__rootNode, 'host')
     return filter(None, map(fptools.safeFunc(self.__parseHostNode),
                (rootHostNode and rootHostNode.children or [])))
Exemplo n.º 10
0
    def __parseSystemFromNameserver(self, nameserverNode):
        r'''
        Partiall structure of NameServer node
            n3>nameserver
             n4>30001
              n5>activated_at=2012-01-05 12:20:05.919
              n5>info
               n6>hostname=x2730 x2730c

        @types: BaseTopologyConfigParser.Node -> sap.System
        '''
        infoNode, nameserverPort = self.__parseNameserverInfoNode(
            nameserverNode)

        # /usr/sap/<sid>/<instance_name>/<hostname>/
        sapRetrievalPath = infoNode.attributes.get('sap_retrieval_path')
        # /usr/sap/<sid>/<instance_name>
        instanceBasePath = infoNode.attributes.get('basepath')

        # find out instance name from paths
        parsePath = fptools.safeFunc(
            sap_discoverer.parseSapSystemFromInstanceBasePath)
        sapSystem = sapRetrievalPath and parsePath(sapRetrievalPath,
                                                   parseHostname=True)
        if not sapSystem and instanceBasePath:
            sapSystem = parsePath(instanceBasePath)
        return sap.System(infoNode.attributes.get('sid')).addInstance(
            sapSystem.getInstances()[0])
Exemplo n.º 11
0
def _reportSystem(sapUtils, system, domain, isSolMan, tmsDomain):
    '@types: SapUtils, System, str, bool, sap.TmsDomain -> osh'
    sapReporter = sap.Reporter(sap.Builder())
    userName = fptools.safeFunc(sapUtils.getUserName)()
    credentialsId = fptools.safeFunc(sapUtils.getCredentialId)()
    systemOsh = sapReporter.reportSystemPdo(
        sap.Builder.SystemPdo(system,
                              ipAddress=sapUtils.getIpAddress(),
                              ipDomain=domain,
                              username=userName,
                              credentialsId=credentialsId,
                              connectionClient=sapUtils.getConnectionClient(),
                              router=sapUtils.getRouter(),
                              isSolutionManager=isSolMan,
                              tmsDomain=tmsDomain))
    return systemOsh
def get_userhome_by_username(shell, username):
    r'shellutils.Shell, basestring -> file_system.Path?'
    pathtool = file_system.getPathToolByShell(shell)
    safe_executor = fptools.safeFunc(
        base_shell_discoverer.get_command_executor(shell))
    return safe_executor(
        base_shell_discoverer.GetUserHomeOnUnix(username, pathtool))
Exemplo n.º 13
0
    def __parseSystemFromNameserver(self, nameserverNode):
        r'''
        Partiall structure of NameServer node
            n3>nameserver
             n4>30001
              n5>activated_at=2012-01-05 12:20:05.919
              n5>info
               n6>hostname=x2730 x2730c

        @types: BaseTopologyConfigParser.Node -> sap.System
        '''
        infoNode, nameserverPort = self.__parseNameserverInfoNode(nameserverNode)

        # /usr/sap/<sid>/<instance_name>/<hostname>/
        sapRetrievalPath = infoNode.attributes.get('sap_retrieval_path')
        # /usr/sap/<sid>/<instance_name>
        instanceBasePath = infoNode.attributes.get('basepath')

        # find out instance name from paths
        parsePath = fptools.safeFunc(sap_discoverer.parseSapSystemFromInstanceBasePath)
        sapSystem = sapRetrievalPath and parsePath(sapRetrievalPath,
                                                   parseHostname=True)
        if not sapSystem and instanceBasePath:
            sapSystem = parsePath(instanceBasePath)
        return sap.System(infoNode.attributes.get('sid')).addInstance(
                          sapSystem.getInstances()[0])
Exemplo n.º 14
0
 def __getProfilePath(self, process):
     r'@types: process.Process -> str or None'
     tokens = re.split('[=\s]+', process.commandLine)
     index = fptools.safeFunc(tokens.index)('pf')
     filePath = None
     if index > 0:
         filePath = tokens[index + 1]
     return filePath
Exemplo n.º 15
0
    def parseSoftwareComponents(self, doc):
        'r@types:org.w3c.dom.Document -> list(JEEDiscovererByHTTP.SoftwareComponent)'
        softwareComponentNodes = self._evalToNodes('/SAP_J2EE/SOFTWARE_COMPONENTS/COMPONENT',
                                      doc)

        buildSoftwareComponentSafely = fptools.safeFunc(self._parseSoftwareComponent)
        res = map(buildSoftwareComponentSafely, softwareComponentNodes)
        return filter(None, res)
Exemplo n.º 16
0
 def __getProfilePath(self, process):
     r'@types: process.Process -> str or None'
     tokens = re.split('[=\s]+', process.commandLine)
     index = fptools.safeFunc(tokens.index)('pf')
     filePath = None
     if index > 0:
         filePath = tokens[index + 1]
     return filePath
Exemplo n.º 17
0
 def getHostNodes(self):
     r'''@types: -> list[HostNode]
     @raise TrexTopologyConfig.NodeNotFound:
     '''
     rootHostNode = getUnderlyingNodeByName(self.__rootNode, 'host')
     return filter(
         None,
         map(fptools.safeFunc(self.__parseHostNode),
             (rootHostNode and rootHostNode.children or [])))
Exemplo n.º 18
0
def buildEndpointsFromNsOption(nsOption, dnsResolver):
    r'''@types: NsOption -> list[netutils.Endpoint]
    '''
    ips = fptools.safeFunc(dnsResolver.resolveIpsByHostname)(nsOption.address)
    if ips:
        return map(fptools.partiallyApply(netutils.createTcpEndpoint,
                                          fptools._,
                                          nsOption.port), ips)
    return []
Exemplo n.º 19
0
def discoverExecutablePath(shell, process):
    r'''
    @types: shellutils.Shell, process.Process -> str or None
    '''
    if shell.isWinOs():
        return process.executablePath
    else:
        return fptools.safeFunc(shell.execCmd)(
            'readlink /proc/%s/exe' % process.getPid())
Exemplo n.º 20
0
def discoverExecutablePath(shell, process):
    r'''
    @types: shellutils.Shell, process.Process -> str or None
    '''
    if shell.isWinOs():
        return process.executablePath
    else:
        return fptools.safeFunc(shell.execCmd)('readlink /proc/%s/exe' %
                                               process.getPid())
Exemplo n.º 21
0
 def parseCentralInstance(self, doc):
     'r@types:org.w3c.dom.Document -> JEEDiscovererByHTTP.CentralInstance'
     centralInstanceNode = self._evalToNode('/SAP_J2EE/CENTRAL_INSTANCE',
                           doc)
     if centralInstanceNode:
         buildInstanceSafely = fptools.safeFunc(fptools.curry(self._parseInstance,
                                                  fptools._,
                                                  self.CentralInstance))
         return buildInstanceSafely(centralInstanceNode)
Exemplo n.º 22
0
 def parseDialogInstances(self, doc):
     'r@types:org.w3c.dom.Document -> list(JEEDiscovererByHTTP.DialogInstance)'
     dialogInstanceNodes = self._evalToNodes('/SAP_J2EE/DIALOG_INSTANCE',
                                   doc)
     buildInstanceSafely = fptools.safeFunc(fptools.curry(self._parseInstance,
                                              fptools._,
                                              self.DialogInstance))
     res = map(buildInstanceSafely, dialogInstanceNodes)
     return filter(None, res)
Exemplo n.º 23
0
def parseFindIpsOutput(resourceProperties, ipMarkers, ipPattern):
    createIp = fptools.safeFunc(ip_addr.IPAddress)
    for ipMarker in ipMarkers:
        for line in resourceProperties.splitlines():
            ipMatcher = re.search(ipPattern % ipMarker, line)
            if ipMatcher:
                ip = createIp(ipMatcher.group(1).strip())
                if ip:
                    return [ip]
    return []
Exemplo n.º 24
0
def get_db_sessions(executor, db_name=None, db_partition_number=None):
    r'''
    @types:
    command.ExecutorCmdlet, str?, str? -> tuple[db2_sql_v9x_discoverer.Session]
    '''
    parse_session = fptools.safeFunc(_parse_session)
    parse_sessions = fptools.partiallyApply(keep, parse_session, fptools._)
    parse_sessions = command.FnCmdlet(parse_sessions)
    sessions = GetApplInfo(db_name) | executor | parse_sessions
    return tuple(sessions)
Exemplo n.º 25
0
def get_db_sessions(executor, db_name=None, db_partition_number=None):
    r'''
    @types:
    command.ExecutorCmdlet, str?, str? -> tuple[db2_sql_v9x_discoverer.Session]
    '''
    parse_session = fptools.safeFunc(_parse_session)
    parse_sessions = fptools.partiallyApply(keep, parse_session, fptools._)
    parse_sessions = command.FnCmdlet(parse_sessions)
    sessions = GetApplInfo(db_name) | executor | parse_sessions
    return tuple(sessions)
Exemplo n.º 26
0
def parseFindIpsOutput(resourceProperties, ipMarkers, ipPattern):
    createIp = fptools.safeFunc(ip_addr.IPAddress)
    for ipMarker in ipMarkers:
        for line in resourceProperties.splitlines():
            ipMatcher = re.search(ipPattern % ipMarker, line)
            if ipMatcher:
                ip = createIp(ipMatcher.group(1).strip())
                if ip:
                    return [ip]
    return []
Exemplo n.º 27
0
def _buildJavaInstance(system, dlgInstance):
    r'@types: System, SapJEEMonitoringXmlParser.DialogInstance -> sap.Instance'
    paths = []
    workers = _getInstanceWorkers(dlgInstance)
    paths.extend(flatten(map(_getPathsWithInstanceBasePath, workers)))
    _parseInstance = partiallyApply(parseInstFromHomeDir, system, fptools._)
    _, inst = untilFirstTruth(safeFunc(_parseInstance), paths)
    if not inst:
        raise Exception("Not enough information to build instance")
    hostname = _getDlgInstanceHostname(dlgInstance)
    return sap.Instance(inst.name, inst.number, hostname)
Exemplo n.º 28
0
    def __getSystemComponent(self, queriedJ2eeType, serviceClass):
        r'@types: str, T -> list[T]'
        parse = fptools.partiallyApply(self.__parseSystemComponent, fptools._,
                                       serviceClass)
        attributes = ("DisplayName", "ProviderName", "MinorVersion",
                      "MicroVersion", "Description", "MajorVersion",
                      "Name", "Jars")

        pattern = '*:*,j2eeType=%s' % queriedJ2eeType
        items = self._getClient().getMbeansByNamePattern(pattern, attributes)
        return keep(fptools.safeFunc(parse), items)
    def parseIpsFromResorceParam(self, resourceProperties, ipPattern):
        ips = []
        ipMarker = "Address"
        createIp = fptools.safeFunc(ip_addr.IPAddress)

        for line in resourceProperties.splitlines():
            ipMatcher = re.search(ipPattern % ipMarker, line.strip())
            if ipMatcher:
                ip = createIp(ipMatcher.group(1).strip())
                if ip:
                    ips.append(ip)
        return ips
Exemplo n.º 30
0
    def _discover_remote_databases(self, context, instname, db2_home_path,
                                   discoverer, executor, interpreter):
        local_dbserver_osh = context.application.applicationOsh
        get_remote_databases = safeFn(discoverer.get_remote_databases)
        node_db_pairs = get_remote_databases(executor, interpreter, instname, db2_home_path=db2_home_path) or ()

        get_node = safeFn(discoverer.get_node)
        reporter = db2_topology.Reporter()
        node_reporter = host_topology.Reporter()

        shell = context.client
        resolvers = (NsLookupDnsResolver(shell), SocketDnsResolver())
        resolve_ips_fn = FallbackResolver(resolvers).resolve_ips
        for nodename, remote_dbs in node_db_pairs:
            node = get_node(executor, interpreter, instname,
                            nodename, db2_home_path=db2_home_path)
            if node:
                host_osh = None
                address = None
                instance_name_ = None
                if node.is_local():
                    host_osh = context.hostOsh
                    address = context.application.getApplicationIp()
                    instance_name_ = node.instance_name
                else:
                    host = host_base_parser.parse_from_address(node.hostname,
                                     fptools.safeFunc(resolve_ips_fn))
                    if host and host.ips:
                        instance_name_ = node.remote_instance_name
                        address = first(host.ips)
                        host_osh, _, oshs_ = node_reporter.report_host_with_ips(host.ips)
                        context.resultsVector.addAll(oshs_)

                if host_osh:
                    get_port_fn = safeFn(discoverer.get_instance_port_by_node)
                    port = get_port_fn(executor, interpreter, node, db2_home_path=db2_home_path)

                    remote_instance = DatabaseServer(address, port)

                    remote_inst_osh, endpoint_osh, _, vector = reporter.reportServerAndDatabases(remote_instance, host_osh)
                    if instance_name_:
                        SoftwareBuilder.updateName(remote_inst_osh, instance_name_)
                        context.resultsVector.addAll(vector)
                        _, oshs = reporter.reportRemoteDatabases(remote_dbs, local_dbserver_osh, remote_inst_osh)
                        context.resultsVector.addAll(oshs)
                    else:
                        logger.debug('No instance name')
                        if endpoint_osh:
                            context.resultsVector.add(endpoint_osh)
                else:
                    logger.debug('Host is not resolved %s' % node.hostname)
            else:
                logger.debug('No node found with name %s' % nodename)
Exemplo n.º 31
0
 def discoverHostInfo(self):
     r'''@types: -> HostDo
     @raise Exception: WMI query failed
     '''
     systemInfo = self.getSystemInfo()
     # There's a limitation of 15 chars for host name in AD
     # while actual host name can be longer
     dnsHostName = fptools.safeFunc(self.getDnsHostname)()
     if (dnsHostName and len(systemInfo.hostName) < len(dnsHostName)
             and dnsHostName.find(systemInfo.hostName) != -1):
         systemInfo.hostName = dnsHostName
     return systemInfo
Exemplo n.º 32
0
def getDomainRootDirPath(shell, fs, process, getParentProcessByPid):
    r'@types: Shell, FileSystem, Process, (long -> Process) -> str or None'
    # find root directory for the process
    # Root directory may be specified as property in command line
    # -Dweblogic.RootDirectory
    cmdLineDescriptor = jee.JvmCommandLineDescriptor(process.commandLine)
    rootDirPath = cmdLineDescriptor.extractProperty('weblogic\.RootDirectory')
    if not rootDirPath:
        # If property is not specified - find out working directory for the process
        if shell.isWinOs():
            # In Windows root directory path can be extracted from the startup script of the.
            # Command line with path to startup script can be found in the
            # parent process for current weblogic process
            parentProcess = getParentProcessByPid(process.getParentPid())
            if parentProcess:
                startupScriptPath = _extractStartupScriptfromCmdPath(
                    parentProcess.commandLine, fs)
                logger.debug("startupScriptPath:", startupScriptPath)
                if startupScriptPath:
                    path = file_system.getPath(fs)
                    rootDirPath = path.dirName(startupScriptPath)
        else:
            rootDirPath = safeFunc(
                getWorkingDirByReadlinkInProc,
                fallbackFn=safeFunc(
                    getWorkingDirByCwd,
                    fallbackFn=safeFunc(
                        getWorkingDirByPwdx,
                        fallbackFn=safeFunc(getWorkingDirByPwdInProc))))(
                            shell, process.getPid())

    if rootDirPath:
        rootDirPath = rootDirPath.strip()
        # check if path ends with bin (in versions starting from 9th)
        if rootDirPath.endswith('bin'):
            rootDirPath = path.dirName(rootDirPath)
        return rootDirPath
    raise ValueError(
        "Domain root directory path cannot be found from the runtime information."
    )
Exemplo n.º 33
0
 def discoverHostInfo(self):
     r'''@types: -> HostDo
     @raise Exception: WMI query failed
     '''
     systemInfo = self.getSystemInfo()
     # There's a limitation of 15 chars for host name in AD
     # while actual host name can be longer
     dnsHostName = fptools.safeFunc(self.getDnsHostname)()
     if (dnsHostName
         and len(systemInfo.hostName) < len(dnsHostName)
         and dnsHostName.find(systemInfo.hostName) != -1):
         systemInfo.hostName = dnsHostName
     return systemInfo
Exemplo n.º 34
0
def getDomainRootDirPath(shell, fs, process, getParentProcessByPid):
    r'@types: Shell, FileSystem, Process, (long -> Process) -> str or None'
    # find root directory for the process
    # Root directory may be specified as property in command line
    # -Dweblogic.RootDirectory
    cmdLineDescriptor = jee.JvmCommandLineDescriptor(process.commandLine)
    rootDirPath = cmdLineDescriptor.extractProperty('weblogic\.RootDirectory')
    if not rootDirPath:
        # If property is not specified - find out working directory for the process
        if shell.isWinOs():
            # In Windows root directory path can be extracted from the startup script of the.
            # Command line with path to startup script can be found in the
            # parent process for current weblogic process
            parentProcess = getParentProcessByPid(process.getParentPid())
            if parentProcess:
                startupScriptPath = _extractStartupScriptfromCmdPath(parentProcess.commandLine, fs)
                logger.debug("startupScriptPath:", startupScriptPath)
                if startupScriptPath:
                    path = file_system.getPath(fs)
                    rootDirPath = path.dirName(startupScriptPath)
        else:
            rootDirPath = safeFunc(getWorkingDirByReadlinkInProc,
                              fallbackFn = safeFunc(getWorkingDirByCwd,
                                   fallbackFn = safeFunc(getWorkingDirByPwdx,
                                         fallbackFn=safeFunc(getWorkingDirByPwdInProc)
                                         )
                              )
                          )(shell, process.getPid())

    if rootDirPath:
        rootDirPath = rootDirPath.strip()
        # check if path ends with bin (in versions starting from 9th)
        if rootDirPath.endswith('bin'):
            rootDirPath = path.dirName(rootDirPath)
        return rootDirPath
    raise ValueError("Domain root directory path cannot be found from the runtime information.")
Exemplo n.º 35
0
    def parseCluster(self, clusterBuffer):
        '''Parses generic Cluster attributes
        @param clusterBuffer: string
        @raise ValueError: Failed to discover Service Guard Cluster
        @return: Cluster with link to Quorum Server if used
        '''
        m = re.search('CLUSTER\s+STATUS\s*\n([\w\-\.]+)\s+(\w+)',
                      clusterBuffer)
        if m:
            clusterName = m.group(1)
            packageIpAddress = netutils.resolveIP(self._shell, clusterName)

            # Discover Quorum server
            # all nodes have reference to the same server
            matchObj = self.QUORUM_SERVER_REGEXP.search(clusterBuffer)
            quorumServer = None
            if matchObj:
                # parse Quorum server information
                createIp = fptools.safeFunc(ip_addr.IPAddress)
                serverAddress = createIp(matchObj.group(3))
                if not serverAddress:
                    logger.warn("Quorum Server IP address is unknown")
                else:
                    endpoint = netutils.createTcpEndpoint(
                        serverAddress, service_guard.QuorumServer.DEFAULT_PORT)
                    status = matchObj.group(2).lower()
                    try:
                        quorumServer = service_guard.QuorumServer(
                            endpoint, status)
                        logger.info("Discovered %s" % quorumServer)
                    except ValueError, ve:
                        logger.warn("Failed to create Quorum Server. %s" % ve)

            return service_guard.Cluster(clusterName,
                                         None,
                                         packageIpAddress,
                                         clusterBuffer,
                                         quorumServer=quorumServer)
Exemplo n.º 36
0
    def parseCluster(self, clusterBuffer):
        '''Parses generic Cluster attributes
        @param clusterBuffer: string
        @raise ValueError: Failed to discover Service Guard Cluster
        @return: Cluster with link to Quorum Server if used
        '''
        m = re.search('CLUSTER\s+STATUS\s*\n([\w\-\.]+)\s+(\w+)', clusterBuffer)
        if m:
            clusterName = m.group(1)
            packageIpAddress = netutils.resolveIP(self._shell, clusterName)

            # Discover Quorum server
            # all nodes have reference to the same server
            matchObj = self.QUORUM_SERVER_REGEXP.search(clusterBuffer)
            quorumServer = None
            if matchObj:
                # parse Quorum server information
                createIp = fptools.safeFunc(ip_addr.IPAddress)
                serverAddress = createIp(matchObj.group(3))
                if not serverAddress:
                    logger.warn("Quorum Server IP address is unknown")
                else:
                    endpoint = netutils.createTcpEndpoint(serverAddress,
                                      service_guard.QuorumServer.DEFAULT_PORT)
                    status = matchObj.group(2).lower()
                    try:
                        quorumServer = service_guard.QuorumServer(endpoint,
                                                                  status)
                        logger.info("Discovered %s" % quorumServer)
                    except ValueError, ve:
                        logger.warn("Failed to create Quorum Server. %s" % ve)

            return service_guard.Cluster(clusterName, None,
                                       packageIpAddress,
                                       clusterBuffer,
                                       quorumServer=quorumServer)
Exemplo n.º 37
0
 def _parseOutput(self, ipconfigBuffer, langBund):
     r"@types: str, ResourceBundle -> list[ip_addr._BaseIP]"
     keyword = langBund.getString("windows_ipconfig_str_dnsservers").strip()
     inDns = 0
     # order of added IPs is important so we do not use set and just check
     # for already added IPs
     ips = []
     parseIp = fptools.safeFunc(self.__parseIpInLine)
     if ipconfigBuffer:
         for line in ipconfigBuffer.splitlines():
             if line.find(keyword) != -1:
                 inDns = 1
                 ip = parseIp(line)
                 if ip and not ip in ips and ip_addr.isValidIpAddressNotZero(ip):
                     ips.append(ip)
                 continue
             if inDns == 1:
                 if line.find(". :") == -1:
                     ip = parseIp(line)
                     if ip and not ip in ips and ip_addr.isValidIpAddressNotZero(ip):
                         ips.append(ip)
                 else:
                     inDns = 0
     return ips
Exemplo n.º 38
0
def _parse_databases(databases):
    return keep(fptools.safeFunc(_parse_database), databases)
Exemplo n.º 39
0
def get_instance_host(executor, dns_resolver):
    r'@types: command.CmdExecutor, dns_resolver.Resolver-> db2_host.Host?'
    hostname = get_instance_hostname(executor)
    resolve_ips = fptools.safeFunc(dns_resolver.resolve_ips)
    return db2_discoverer.get_host(hostname, resolve_ips)
Exemplo n.º 40
0
def _parse_remote_databases(pairs):
    return keep(fptools.safeFunc(_parse_remote_database), pairs)
Exemplo n.º 41
0
def _parse_buffer_pools(items):
    return keep(fptools.safeFunc(_parse_buffer_pool), items)
Exemplo n.º 42
0
def _parse_tables(items):
    return keep(fptools.safeFunc(_parse_table), items)
Exemplo n.º 43
0
def _parse_partitions(items):
    return keep(fptools.safeFunc(_parse_partition), items)
Exemplo n.º 44
0
def _parse_partition_id_to_pg_names(items):
    return keep(fptools.safeFunc(_parse_partition_id_to_pg_name), items)
Exemplo n.º 45
0
def _parse_partition_groups(items):
    return keep(fptools.safeFunc(_parse_partition_group), items)
Exemplo n.º 46
0
def _parse_containers(items):
    return keep(fptools.safeFunc(_parse_container), items)
Exemplo n.º 47
0
def _findIps(resourceProperties, ipMarkers):
    '@types: str, seq[str] -> list[ip_addr._BaseIP]'
    if resourceProperties:
        createIp = fptools.safeFunc(ip_addr.IPAddress)
        ipPattern = '\s+%s\s+(\S*)$'
        return parseFindIpsOutput(resourceProperties, ipMarkers, ipPattern)
Exemplo n.º 48
0
    def decorator_fn(main_fn):
        @wraps(main_fn)
        def wrapper(framework):
            vector = ObjectStateHolderVector()
            framework = RichFramework(framework)
            creds_manager = CredsManager(framework)
            creds = get_credentials_fn(framework, creds_manager)

            if creds is None:
                return vector

            first_cred = take(0, 1, creds)
            if not first_cred:
                logger.reportErrorObject(
                    _create_missed_creds_error(proto_name))
            else:
                connection_exs = []
                discovery_exs = []
                warnings = []
                at_least_once_discovered = False
                oshs = []

                creds = list(itertools.chain(first_cred, creds))

                if with_dns_resolver:
                    local_client = framework.createClient(
                        LOCAL_SHELL_PROTOCOL_NAME)
                    local_shell = shellutils.ShellUtils(local_client)
                    dns_resolver = _get_dns_resolver(local_shell)

                for args in starmap(
                        functools.partial(cred_to_client_args, creds_manager),
                        creds):
                    try:
                        with create_client(framework, *args) as client:

                            args = with_dns_resolver and (
                                dns_resolver, ) + args or args

                            oshs_, warnings_ = main_fn(client, framework,
                                                       *args)
                            oshs.extend(oshs_)
                            warnings.extend(warnings_)
                            at_least_once_discovered = True
                            if stop_on_first:
                                break
                    except ConnectionException, ce:
                        logger.debugException(str(ce))
                        connection_exs.append(ce)
                    except (DiscoveryException, Exception), de:
                        logger.debugException(str(de))
                        discovery_exs.append(de)

                if with_dns_resolver:
                    fptools.safeFunc(local_shell.closeClient)()

                if at_least_once_discovered:
                    each(logger.reportWarningObject, warnings)
                else:
                    for ex in connection_exs:
                        obj = _create_connection_errorobj(
                            proto_name, ex.message)
                        logger.reportErrorObject(obj)
                    for ex in discovery_exs:
                        obj = _create_discovery_errorobj(
                            proto_name, '', ex.message)
                        logger.reportErrorObject(obj)
                vector.addAll(oshs)
Exemplo n.º 49
0
def _discoverTopology(clusterCmd, languageBundle, dnsResolver):
    r'@types: ClusterCmd, ResourceBundle, DNSResolver -> ObjectStateHolderVector'
    vector = ObjectStateHolderVector()

    # DISCOVER cluster basic topology (cluster + nodes)
    if clusterCmd.isUsingCmd():
        getCluster = clusterCmd.getCluster
    else:
        getCluster = clusterCmd.getClusterByPowerShell

    cluster = ms_cluster.createClusterWithDetails(getCluster(),
        fptools.safeFunc(clusterCmd.getClusterDetails)())
    logger.info("Found ", cluster)
    # DISCOVER nodes
    nodes = []
    detailsContentByName = {}
    getNodeAddress = fptools.safeFunc(clusterCmd.getHostAddressesbyNetinterface)
    ipsByNodeName = {}
    for node in clusterCmd.findNodes():
        logger.info("Discovered %s" % node)
        # in case if IP of node cannot be resolved there is no need to continue
        # discovery of this node
        ips = (dnsResolver.resolve_ips(node.name)
               or getNodeAddress(node.name))
        if not ips:
            logger.warn("Skip %s due to not resolved address" % node)
            continue
        ipsByNodeName[node.name.lower()] = ips

        details = None
        try:
            details = clusterCmd.getNodeDetails(node.name)
            buffer = clusterCmd.getLastCommandOutput()
            detailsContentByName[node.name.lower()] = buffer
        except Exception:
            logger.warnException("Failed to get details for %s" % node)

        # if needed re-create node with details in it
        nodes.append((details
                      and ms_cluster.Node(node.name, details=details)
                      or node))

    # REPORT cluster topology
    clusterBuilder = ms_cluster.Builder()
    clusterPdo = clusterBuilder.Pdo(cluster, len(nodes))
    clusterOsh = clusterBuilder.buildClusterPdo(clusterPdo)
    vector.add(clusterOsh)

    # REPORT nodes
    softwareOshByNodeName = {}
    for node in nodes:
        softwareOsh, nodeVector = _reportNode(
            node, cluster, ipsByNodeName.get(node.name.lower()), clusterOsh,
            dnsResolver.resolve_fqdn(node.name),
            detailsContentByName.get(node.name.lower()))
        vector.addAll(nodeVector)
        softwareOshByNodeName[node.name.lower()] = softwareOsh

    # DISCOVER resource groups
    if len(nodes) > 0:
        resourceBuilder = ms_cluster.ResourceBuilder()
        resourceReporter = ms_cluster.ResourceReporter(resourceBuilder)
        groups = clusterCmd.getResourceGroups()
        for group in groups:
            logger.info("Found %s" % group)
            groupDetails = fptools.safeFunc(clusterCmd.getResourceGroupDetails)(group.name)
            # update group with details
            groupDetailsContent = None
            if groupDetails:
                groupDetailsContent = clusterCmd.getLastCommandOutput()
                group = ms_cluster.ResourceGroup(group.name, group.nodeName,
                    groupDetails)
            else:
                logger.warn("Failed to get details")
            if clusterCmd.isUsingCmd():
                groupOwners = fptools.safeFunc(clusterCmd.getResourceGroupOwners)(group.name) or ()
            else:
                groupOwners = fptools.safeFunc(clusterCmd.getResourceGroupOwnersByPowerShell)(group.name) or ()
            if groupOwners:
                logger.info("Group owners are %s" % groupOwners)
                # get resources in the group and filter only IP resources
            resources = []
            # for this group resources get their details
            dependenciesByGroupName = {}
            privateDetBufferByResourceName = {}
            publicDetBufferByResourceName = {}
            logger.info("Discover group resources")
            try:
                if clusterCmd.isUsingCmd():
                    groupResources = clusterCmd.getResourcesByGroup(group.name)
                else:
                    groupResources = clusterCmd.getResourcesByGroupByPowerShell(group.name)
            except ms_cluster_discoverer.ClusterCmd.ExecuteException:
                logger.warn("Failed to find resources for %s" % group)
            else:
                for resource in groupResources:
                    logger.info("\tFound %s" % resource)
                    try:
                        resourceDetails = clusterCmd.getResourceDetails(resource.name)
                        publicDetBufferByResourceName[resource.name] = clusterCmd.getLastCommandOutput()
                        resource = ms_cluster.Resource(resource.name,
                            resource.groupName, resource.status, resourceDetails)
                    except Exception:
                        logger.warnException("Failed to get %s details" % resource)
                    try:
                        clusterCmd.getResourcePrivateDetails(resource.name)
                        privateDetBuffer = clusterCmd.getLastCommandOutput()
                        privateDetBufferByResourceName[resource.name.lower()] = privateDetBuffer
                        if resourceDetails.type == 'Network Name':
                            (networkName, fqdn )= ms_cluster_discoverer.getCrgNeworkNames(privateDetBuffer, dnsResolver)
                            if networkName or fqdn:
                                group = ms_cluster.ResourceGroup(group.name, group.nodeName,
                                    groupDetails, networkName, fqdn)
                    except Exception:
                        logger.warnException("Failed to get %s private details" % resource)
                    try:
                        dependencies = clusterCmd.getResourceDependencies(resource.name, group.name)
                        dependenciesByGroupName[resource.name.lower()] = dependencies
                        if dependencies:
                            logger.info("\t\tDependencies are %s" % dependencies)
                    except Exception:
                        logger.warnException("Failed to get %s dependencies")
                    resources.append(resource)

            # REPORT cluster resources
            # report clustered service
            builder = ms_cluster.ClusteredServiceBuilder()
            serviceOsh = builder.buildClusteredService(cluster, group)
            vector.add(serviceOsh)
            vector.add(modeling.createLinkOSH('contained', clusterOsh,
                serviceOsh))

            softwareOsh = softwareOshByNodeName.get(group.nodeName.lower())
            if not softwareOsh:
                logger.warn("Failed to find node of %s" % group)
            else:
                runOsh = modeling.createLinkOSH('run', softwareOsh, serviceOsh)
                vector.add(runOsh)

            for softwareOsh in softwareOshByNodeName.values():
                runOsh = modeling.createLinkOSH('potentially_run',
                    softwareOsh, serviceOsh)
                vector.add(runOsh)

            groupReporter = ms_cluster.ResourceGroupReporter(ms_cluster.ResourceGroupBuilder())
            groupOsh = groupReporter.reportGroup(group, serviceOsh)
            vector.add(groupOsh)

            # report group details
            if groupDetailsContent:
                vector.add(_reportGroupDetails(group, groupDetailsContent, groupOsh))

            # report linkage between group owners
            for ownerNodeName in groupOwners:
                # resolve node IPs by owner-node name
                ips = (
                    dnsResolver.resolve_ips(ownerNodeName)
                    or fptools.safeFunc(clusterCmd.getHostAddressesbyNetinterface)
                        (ownerNodeName))
                if not ips:
                    logger.warn("Failed to resolve address for %s" % node)
                    continue
                fqdn = dnsResolver.resolve_fqdn(ownerNodeName)
                vector.addAll(_reportHost(ips, fqdn)[1])
                vector.add(_buildOwnerPotentillyRun(softwareOsh, serviceOsh))

            # report resources
            for resource in resources:
                clusterResourcesPrivBuffer = privateDetBufferByResourceName.get(resource.name.lower())
                pdo = ms_cluster.ResourceBuilder.Pdo(resource, clusterResourcesPrivBuffer)
                resourceOsh = resourceReporter.reportResourcePdo(pdo, groupOsh)
                vector.add(resourceOsh)

                # and dependent resources
                for dependency in dependenciesByGroupName.get(resource.name.lower(), ()):
                    dependencyOsh = resourceReporter.reportResource(dependency, groupOsh)
                    vector.add(dependencyOsh)
                    dependOsh = modeling.createLinkOSH('depend', dependencyOsh, resourceOsh)
                    vector.add(dependOsh)

            # filter resource of type "IP Address" to gather group IPs
            ipResources = filter(ms_cluster.isIpAddressResource, resources)
            addressWord = languageBundle.getString('resource_ip_address_name')
            # look for the IP value inside private properties
            groupIps = []
            logger.info("Look for the IP resources in %s resources" % len(ipResources))
            for resource in ipResources:
                if clusterCmd.isUsingCmd():
                    groupIps.extend(_findIps(
                        privateDetBufferByResourceName.get(resource.name.lower()),
                        (addressWord, 'Address', 'Adresse')))
                else:
                    groupIps.extend(_findIpsByPowerShell(
                        privateDetBufferByResourceName.get(resource.name.lower()),
                        (addressWord, 'Address', 'Adresse')))

            for ip in groupIps:
                logger.info('Found IP(%s) for virtual cluster group %s' % (ip, group.name))
                ipOsh = modeling.createIpOSH(ip)
                containedOsh = modeling.createLinkOSH('contained', serviceOsh, ipOsh)
                vector.add(containedOsh)
                vector.add(ipOsh)
            #check if CRG name is a valid DNS name
            fqdn = group.fqdn
            if not fqdn:
                fqdn = dnsResolver.resolve_fqdn(group.name)
                if fqdn:
                    serviceOsh.setStringAttribute('primary_dns_name', fqdn)
            if not groupIps:
                logger.warn('Failed to resolve cluster IP for group %s' % group.name)
            elif not fqdn:
                primaryIp = groupIps[0]
                fqdn = dnsResolver.resolve_ips(str(primaryIp))
                if fqdn:
                    serviceOsh.setStringAttribute('primary_dns_name', fqdn[0])
    else:
        raise NoInstanceFound()
    return vector
Exemplo n.º 50
0
def __create_valid_ip(ip_string):
    ip = fptools.safeFunc(ip_addr.IPAddress)(ip_string)
    if ip and netutils.isRoutableIp(ip):
        return ip
    return ip
Exemplo n.º 51
0
        # discover all processes
        runningProcesses = processDiscoverer.discoverAllProcesses()
        # make filtering for Weblogic processes
        serverProcesses = filter(isWeblogicAsProcess, runningProcesses)
        # obvious to terminate discovery job without weblogic processes running
        if not serverProcesses:
            logger.reportWarning("No Weblogic processes currently running")
            return ObjectStateHolderVector()
        # create catalog of processes by PID
        processByPid = applyMapping(processModule.Process.getPid, runningProcesses)

        # for each weblogic server process get root directory path
        getRootDirectoryPath = curry(getDomainRootDirPath,
                                     shell, fs, _, processByPid.get
        )
        rootDirectoryPaths = map(safeFunc(getRootDirectoryPath), serverProcesses)
        # group server processes by root directory path
        processesByRootDirPath = {}
        for process, path in zip(serverProcesses, rootDirectoryPaths):
            processesByRootDirPath.setdefault(path, []).append(process)
        debugGroups(processesByRootDirPath)

        # NEXT CASE IS NOT SUPPORTED (as property weblogic.ConfigFile
        #     removed starting from version 9
        # important to understand that some processes may specify alternative
        # path to the configuration
        #     -Dweblogic.ConfigFile=c:\mydir\myfile.xml
        # OR
        # Instead, use the following arguments:
        #     -Dweblogic.RootDirectory=c:\mydir
        #     -Dweblogic.ConfigFile=myfile.xml