Beispiel #1
0
 def _getAdapterBindings(self, adapterNode):
     result = []
     xpath = self.getXPath()
     bindings = xpath.evaluate(r'bindings/binding', adapterNode,
                               XPathConstants.NODESET)
     if bindings:
         for bindingNum in xrange(bindings.getLength()):
             bindingNode = bindings.item(bindingNum)
             bindingName = xpath.evaluate(r'@name', bindingNode,
                                          XPathConstants.STRING)
             bindingMachine = xpath.evaluate(r'machine', bindingNode,
                                             XPathConstants.STRING)
             # Resolve machine IP
             try:
                 ip = netutils.getLowestIp(
                     self._dnsResolver.resolveIpsByHostname(bindingMachine))
             except:
                 logger.warn("Failed to resolve: ", bindingMachine)
             else:
                 bindingMachine = ip
                 bindingProductType = xpath.evaluate(
                     r'product/type', bindingNode, XPathConstants.STRING)
                 bindingProductVersion = xpath.evaluate(
                     r'product/version', bindingNode, XPathConstants.STRING)
                 bindingProductLocation = xpath.evaluate(
                     r'product/location', bindingNode,
                     XPathConstants.STRING)
                 binding = tibco.AdapterBinding(
                     bindingName, bindingMachine,
                     tibco.Product(bindingProductType,
                                   bindingProductVersion,
                                   bindingProductLocation))
                 result.append(binding)
     return result
Beispiel #2
0
 def _getAdapterBindings(self, adapterNode):
     result = []
     xpath = self.getXPath()
     bindings = xpath.evaluate(r'bindings/binding', adapterNode, XPathConstants.NODESET)
     if bindings:
         for bindingNum in xrange(bindings.getLength()):
             bindingNode = bindings.item(bindingNum)
             bindingName = xpath.evaluate(r'@name', bindingNode, XPathConstants.STRING)
             bindingMachine = xpath.evaluate(r'machine', bindingNode, XPathConstants.STRING)
             # Resolve machine IP
             try:
                 ip = netutils.getLowestIp(self._dnsResolver.resolveIpsByHostname(bindingMachine))
             except:
                 logger.warn("Failed to resolve: ", bindingMachine)
             else:
                 bindingMachine = ip
                 bindingProductType = xpath.evaluate(r'product/type', bindingNode, XPathConstants.STRING)
                 bindingProductVersion = xpath.evaluate(r'product/version', bindingNode, XPathConstants.STRING)
                 bindingProductLocation = xpath.evaluate(r'product/location', bindingNode, XPathConstants.STRING)
                 binding = tibco.AdapterBinding(bindingName, bindingMachine, tibco.Product(bindingProductType, bindingProductVersion, bindingProductLocation))
                 result.append(binding)
     return result
Beispiel #3
0
def DiscoveryMain(Framework):
    OshvResult = ObjectStateHolderVector()
    hostOsh = None

    ## Destination data
    hostId = Framework.getDestinationAttribute('hostId') or None
    processRootId = Framework.getDestinationAttribute('processRootId') or None
    processPath = Framework.getDestinationAttribute('processPath') or None
    processCmdLine = Framework.getDestinationAttribute('processCmdLine') or None
    protocol = Framework.getDestinationAttribute('Protocol')
    ipAddress = Framework.getDestinationAttribute('ip_address')
    raw_paths = Framework.getParameter('emsadmin_tool_absolute_paths') or ''
    default_paths = [x.strip() for x in raw_paths.split(',')]
    ## Pattern parameters
    isJmsQueueDiscoveryEnabled = Boolean.valueOf(Framework.getParameter('discover_queues'))
    isJmsTopicDiscoveryEnabled = Boolean.valueOf(Framework.getParameter('discover_topics'))

    ## Container HOST OSH
    if hostId:
        hostOsh = modeling.createOshByCmdbIdString('host', hostId.strip())
        OshvResult.add(hostOsh)
        logger.debug('[' + __name__ + ':DiscoveryMain] Got HOSTID <%s>' % hostId)

    ## EMS OSH
    if processRootId:
        processOsh = modeling.createOshByCmdbIdString('process', processRootId.strip())
        OshvResult.add(processOsh)
        logger.debug('[' + __name__ + ':DiscoveryMain] Got Process ID <%s>' % processRootId)
    else:
        errMsg = "Invalid Tibco EMS Server CI ID received from server. This EMS server will not be processed"
        logger.error(errMsg)
        logger.reportError(errMsg)
        return OshvResult

    emsTopology = []
    # Attempt to create a shell client
    try:
        client = Framework.createClient()
        shell = shellutils.ShellFactory().createShell(client)
        fallbackDnsResolver = tibco_discoverer.FallbackResolver([netutils.JavaDnsResolver(), netutils.DnsResolverByShell(shell)])
        dnsResolver = tibco_discoverer.CachedResolver(fallbackDnsResolver)

        fs = file_system.createFileSystem(shell)
        emsShellDiscoverer = tibco_discoverer.EmsDiscovererByShell(shell, fs)

        pathUtils = file_system.getPath(fs)
        emsPath = "%s/" % pathUtils.dirName(processPath)
        default_paths.insert(0, emsPath)
        # find out whether emsadmin tool exists and config path present in command line
        for ems_path in default_paths:
            configPath = emsShellDiscoverer.discoverConfigPath(ems_path, processCmdLine)
            if configPath:
                emsPath = ems_path
                logger.debug('Found ems admin utility path %s' % emsPath)
                logger.debug('Found ems config file path %s' % configPath)
                break
        if not emsPath:
            raise ValueError('Failed to discover ems admin utility path. No discovery possible.')
        listenUrls = emsShellDiscoverer.getListenUrls(configPath)
        credList = Framework.getAvailableProtocols(ipAddress, tibco.TIBCO_PROTOCOL)
        # Check if exists any credentials for TIBCO
        if credList:
            for cred in credList:
                for listenUrl in listenUrls:
                    try:
                        emsAdminCommand = tibco_discoverer.EmsAdminCommand(client, cred, emsPath, listenUrl)
                        if testConnection(emsAdminCommand):
                            emsDiscoverer = tibco_discoverer.EmsDiscovererByAdminCommand(emsAdminCommand)
                            emsServer = emsDiscoverer.getEmsServerInfo()
                            jmsServer = emsDiscoverer.extractJmsServerInfoFromUrl(listenUrl)

                            if jmsServer:
                                hostname = jmsServer.hostname
                                try:
                                    ip = dnsResolver.resolveIpsByHostname(hostname)
                                    jmsServer.hostname = netutils.getLowestIp(ip)
                                except:
                                    logger.debug("Cannot resolve %s host" % hostname)
                            if emsServer:
                                emsQueues = isJmsQueueDiscoveryEnabled and emsDiscoverer.getQueues()
                                emsTopics = isJmsTopicDiscoveryEnabled and emsDiscoverer.getTopics()
                            destinations = []
                            if emsQueues or emsTopics:
                                emsQueues and destinations.extend(emsQueues)
                                emsTopics and destinations.extend(emsTopics)
                            emsDataItem = tibco_discoverer.EmsTopology(emsServer, jmsServer, destinations)
                            emsTopology.append(emsDataItem)
                    except tibco_discoverer.TibcoDiscovererException, ex:
                        reportError(str(ex), tibco.TIBCO_PROTOCOL, Framework)
                    except Exception, ex:
                        reportError(str(ex), protocol, Framework)
                    except JException, ex:
                        msg = ex.getMessage()
                        logger.debugException(msg)
                        errormessages.resolveAndReport(msg, protocol, Framework)
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    client = None
    hostOsh = None
    shell = None

    ## Destination data
    hostId = Framework.getDestinationAttribute('hostId') or None
    bwId = Framework.getDestinationAttribute('bwId') or None
    bwPath = Framework.getDestinationAttribute('bwPath') or None
    protocol = Framework.getDestinationAttribute('Protocol')
    ip_address = Framework.getDestinationAttribute('ip_address')
    tmpDirPath = Framework.getParameter('temp_directory') or '/tmp'
    isDiscoverJms = Framework.getParameter('discover_jms_topology') or "true"
    isDiscoverJms = Boolean.valueOf(isDiscoverJms)

    ## Container HOST OSH
    if hostId:
        hostOsh = modeling.createOshByCmdbIdString('node', hostId.strip())
        OSHVResult.add(hostOsh)
        logger.debug('[' + __name__ + ':DiscoveryMain] Got HOSTID <%s>' % hostId)

    ## Pre-discovered Business Works CI
    bwOsh = None
    if bwId:
        bwOsh = modeling.createOshByCmdbIdString('tibco_business_works', bwId.strip())
        logger.debug('[' + __name__ + ':DiscoveryMain] Got bwId <%s>' % bwId)
    else:
        errMsg = '[' + __name__ + ':DiscoveryMain] Invalid TibcoBusinessWorks CI ID received from server. This BW will not be processed'
        logger.error(errMsg)
        logger.reportError(errMsg)
        return OSHVResult


    if not tmpDirPath:
        errMsg = '[' + __name__ + ':DiscoveryMain] temp_directory parameter has not been set correctly. Discovery cannot continue until this parameter is set with a remote directory with write permissions.'
        logger.error(errMsg)
        logger.reportError(errMsg)
        return OSHVResult

    try:
        try:
            client = Framework.createClient()
            shell = shellutils.ShellFactory().createShell(client)
            credList = Framework.getAvailableProtocols(ip_address, tibco.TIBCO_PROTOCOL)
            logger.info("Found tibco credentials: %s" % len(credList))

            fs = tibco_discoverer.createFileSystem(shell)

            bw = tibco_discoverer.BusinessWorksDiscoverer().findBWVersionFromPath(bwPath)
            domains = tibco_discoverer.BusinessWorksDomainDiscoverer(shell, fs).discover(bwPath)
            traHomeDiscoverer = tibco_discoverer.TicboTraHomeDiscoverer(shell)
            traHomes = traHomeDiscoverer.discover()
            fallbackDnsResolver = tibco_discoverer.FallbackResolver([netutils.JavaDnsResolver(), netutils.DnsResolverByShell(shell)])
            dnsResolver = tibco_discoverer.CachedResolver(fallbackDnsResolver)

            if traHomes and bw:
                traPath = traHomes[0]
                for domain in domains:
                    logger.info("Visit %s" % domain)
                    try:
                        applications = None
                        # Check if we have any credential for TIBCO
                        if credList:
                            for credId in credList:
                                adminCommand = tibco_discoverer.AppManageAdminCommand(client, credId, "./")
                                adapterDiscoverer = tibco_discoverer.TibcoAdapterDiscoverer(dnsResolver)
                                appDiscoverer = tibco_discoverer.BusinessWorksApplicationDiscoverer(shell, fs, adminCommand, adapterDiscoverer)
                                applications = appDiscoverer.discover(domain.getName(), traPath, tmpDirPath, discoverJmsTopology=isDiscoverJms)
                            if applications:
                                tibco.each(domain.addApplication, applications)
                        else:
                            msg = errormessages.makeErrorMessage(tibco.TIBCO_PROTOCOL, pattern=errormessages.ERROR_NO_CREDENTIALS)
                            errobj = errorobject.createError(errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP, [ tibco.TIBCO_PROTOCOL ], msg)
                            logger.reportErrorObject(errobj)

                        bw.addDomain(domain)
                    except tibco_discoverer.TibcoDiscovererException, exc:
                        logger.debugException(str(exc))
                        errorobj = errorobject.createError(errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE, [ 'tibco', 'error: %s' % str(exc)], str(exc))
                        logger.reportErrorObject(errorobj)
        except:
            logger.debugException('')
            exInfo = logger.prepareJythonStackTrace('[' + __name__ + ':DiscoveryMain] Error connecting: ')
            errormessages.resolveAndReport(exInfo, protocol, Framework)
        else:
            # Reporting
            logger.debug("--- Start reporting ---")
            reporter = tibco.TopologyReporter(tibco.TopologyBuilder())
            bwOsh = reporter.reportBusinessWorks(bw, hostOsh, bwId)
            OSHVResult.add(bwOsh)
            endpointReporter = netutils.EndpointReporter(netutils.ServiceEndpointBuilder())

            for domain in domains:
                domainOsh = reporter.reportBusinessWorksDomain(domain)
                OSHVResult.add(domainOsh)
                OSHVResult.add(reporter.reportBWAndDomainLink(domainOsh, bwOsh))
                for app in domain.getApplications():
                    appOsh = reporter.reportBusinessWorksApp(app, bwOsh)
                    OSHVResult.add(appOsh)
                    if app.getJmsServers():
                        for jmsServer in app.getJmsServers():

                            # Trying to resolver host name
                            try:
                                ip = netutils.getLowestIp(dnsResolver.resolveIpsByHostname(jmsServer.hostname))
                                if ip:
                                    jmsServer.hostname = ip
                            except Exception, ex:
                                logger.debugException(str(ex))

                            if netutils.isValidIp(jmsServer.hostname) and not netutils.isLoopbackIp(jmsServer.hostname):
                                jmsHostOsh = modeling.createHostOSH(jmsServer.hostname)
                                emsServerOsh = reporter.reportEMSServer(tibco.EmsServer(), jmsHostOsh)
                                jmsServerOsh = reporter.reportJmsServer(jmsServer, emsServerOsh)
                                endpoint = netutils.createTcpEndpoint(jmsServer.hostname, jmsServer.getPort())
                                serviceOsh = endpointReporter.reportEndpoint(endpoint, jmsHostOsh)
                                linkOsh = reporter.reportEmsServerServiceAddressLink(emsServerOsh, serviceOsh)
                                OSHVResult.add(emsServerOsh)
                                OSHVResult.add(jmsHostOsh)
                                OSHVResult.add(jmsServerOsh)
                                OSHVResult.add(serviceOsh)
                                OSHVResult.add(linkOsh)
                                for jmsQueue in app.getJmsQueues():
                                    OSHVResult.addAll(reporter.reportJmsDestinationTopology(jmsQueue, jmsServerOsh, appOsh))
                                for jmsTopic in app.getJmsTopics():
                                    OSHVResult.addAll(reporter.reportJmsDestinationTopology(jmsTopic, jmsServerOsh, appOsh))
                    if app.getAdapters():
                        for adapter in app.getAdapters():
                            OSHVResult.addAll(reporter.reportAdapterTopology(adapter, appOsh))

    finally:
        if shell:
            ## Close shell connection
            shell.closeClient()

    return OSHVResult
Beispiel #5
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    client = None
    hostOsh = None
    shell = None

    ## Destination data
    hostId = Framework.getDestinationAttribute('hostId') or None
    bwId = Framework.getDestinationAttribute('bwId') or None
    bwPath = Framework.getDestinationAttribute('bwPath') or None
    protocol = Framework.getDestinationAttribute('Protocol')
    ip_address = Framework.getDestinationAttribute('ip_address')
    tmpDirPath = Framework.getParameter('temp_directory') or '/tmp'
    isDiscoverJms = Framework.getParameter('discover_jms_topology') or "true"
    isDiscoverJms = Boolean.valueOf(isDiscoverJms)

    ## Container HOST OSH
    if hostId:
        hostOsh = modeling.createOshByCmdbIdString('node', hostId.strip())
        OSHVResult.add(hostOsh)
        logger.debug('[' + __name__ +
                     ':DiscoveryMain] Got HOSTID <%s>' % hostId)

    ## Pre-discovered Business Works CI
    bwOsh = None
    if bwId:
        bwOsh = modeling.createOshByCmdbIdString('tibco_business_works',
                                                 bwId.strip())
        logger.debug('[' + __name__ + ':DiscoveryMain] Got bwId <%s>' % bwId)
    else:
        errMsg = '[' + __name__ + ':DiscoveryMain] Invalid TibcoBusinessWorks CI ID received from server. This BW will not be processed'
        logger.error(errMsg)
        logger.reportError(errMsg)
        return OSHVResult

    if not tmpDirPath:
        errMsg = '[' + __name__ + ':DiscoveryMain] temp_directory parameter has not been set correctly. Discovery cannot continue until this parameter is set with a remote directory with write permissions.'
        logger.error(errMsg)
        logger.reportError(errMsg)
        return OSHVResult

    try:
        try:
            client = Framework.createClient()
            shell = shellutils.ShellFactory().createShell(client)
            credList = Framework.getAvailableProtocols(ip_address,
                                                       tibco.TIBCO_PROTOCOL)
            logger.info("Found tibco credentials: %s" % len(credList))

            fs = tibco_discoverer.createFileSystem(shell)

            bw = tibco_discoverer.BusinessWorksDiscoverer(
            ).findBWVersionFromPath(bwPath)
            domains = tibco_discoverer.BusinessWorksDomainDiscoverer(
                shell, fs).discover(bwPath)
            traHomeDiscoverer = tibco_discoverer.TicboTraHomeDiscoverer(shell)
            traHomes = traHomeDiscoverer.discover()
            fallbackDnsResolver = tibco_discoverer.FallbackResolver([
                netutils.JavaDnsResolver(),
                netutils.DnsResolverByShell(shell)
            ])
            dnsResolver = tibco_discoverer.CachedResolver(fallbackDnsResolver)

            if traHomes and bw:
                traPath = traHomes[0]
                for domain in domains:
                    logger.info("Visit %s" % domain)
                    try:
                        applications = None
                        # Check if we have any credential for TIBCO
                        if credList:
                            for credId in credList:
                                adminCommand = tibco_discoverer.AppManageAdminCommand(
                                    client, credId, "./")
                                adapterDiscoverer = tibco_discoverer.TibcoAdapterDiscoverer(
                                    dnsResolver)
                                appDiscoverer = tibco_discoverer.BusinessWorksApplicationDiscoverer(
                                    shell, fs, adminCommand, adapterDiscoverer)
                                applications = appDiscoverer.discover(
                                    domain.getName(),
                                    traPath,
                                    tmpDirPath,
                                    discoverJmsTopology=isDiscoverJms)
                            if applications:
                                tibco.each(domain.addApplication, applications)
                        else:
                            msg = errormessages.makeErrorMessage(
                                tibco.TIBCO_PROTOCOL,
                                pattern=errormessages.ERROR_NO_CREDENTIALS)
                            errobj = errorobject.createError(
                                errorcodes.NO_CREDENTIALS_FOR_TRIGGERED_IP,
                                [tibco.TIBCO_PROTOCOL], msg)
                            logger.reportErrorObject(errobj)

                        bw.addDomain(domain)
                    except tibco_discoverer.TibcoDiscovererException, exc:
                        logger.debugException(str(exc))
                        errorobj = errorobject.createError(
                            errorcodes.
                            FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE,
                            ['tibco', 'error: %s' % str(exc)], str(exc))
                        logger.reportErrorObject(errorobj)
        except:
            logger.debugException('')
            exInfo = logger.prepareJythonStackTrace(
                '[' + __name__ + ':DiscoveryMain] Error connecting: ')
            errormessages.resolveAndReport(exInfo, protocol, Framework)
        else:
            # Reporting
            logger.debug("--- Start reporting ---")
            reporter = tibco.TopologyReporter(tibco.TopologyBuilder())
            bwOsh = reporter.reportBusinessWorks(bw, hostOsh, bwId)
            OSHVResult.add(bwOsh)
            endpointReporter = netutils.EndpointReporter(
                netutils.ServiceEndpointBuilder())

            for domain in domains:
                domainOsh = reporter.reportBusinessWorksDomain(domain)
                OSHVResult.add(domainOsh)
                OSHVResult.add(reporter.reportBWAndDomainLink(
                    domainOsh, bwOsh))
                for app in domain.getApplications():
                    appOsh = reporter.reportBusinessWorksApp(app, bwOsh)
                    OSHVResult.add(appOsh)
                    if app.getJmsServers():
                        for jmsServer in app.getJmsServers():

                            # Trying to resolver host name
                            try:
                                ip = netutils.getLowestIp(
                                    dnsResolver.resolveIpsByHostname(
                                        jmsServer.hostname))
                                if ip:
                                    jmsServer.hostname = ip
                            except Exception, ex:
                                logger.debugException(str(ex))

                            if netutils.isValidIp(
                                    jmsServer.hostname
                            ) and not netutils.isLoopbackIp(
                                    jmsServer.hostname):
                                jmsHostOsh = modeling.createHostOSH(
                                    jmsServer.hostname)
                                emsServerOsh = reporter.reportEMSServer(
                                    tibco.EmsServer(), jmsHostOsh)
                                jmsServerOsh = reporter.reportJmsServer(
                                    jmsServer, emsServerOsh)
                                endpoint = netutils.createTcpEndpoint(
                                    jmsServer.hostname, jmsServer.getPort())
                                serviceOsh = endpointReporter.reportEndpoint(
                                    endpoint, jmsHostOsh)
                                linkOsh = reporter.reportEmsServerServiceAddressLink(
                                    emsServerOsh, serviceOsh)
                                OSHVResult.add(emsServerOsh)
                                OSHVResult.add(jmsHostOsh)
                                OSHVResult.add(jmsServerOsh)
                                OSHVResult.add(serviceOsh)
                                OSHVResult.add(linkOsh)
                                for jmsQueue in app.getJmsQueues():
                                    OSHVResult.addAll(
                                        reporter.reportJmsDestinationTopology(
                                            jmsQueue, jmsServerOsh, appOsh))
                                for jmsTopic in app.getJmsTopics():
                                    OSHVResult.addAll(
                                        reporter.reportJmsDestinationTopology(
                                            jmsTopic, jmsServerOsh, appOsh))
                    if app.getAdapters():
                        for adapter in app.getAdapters():
                            OSHVResult.addAll(
                                reporter.reportAdapterTopology(
                                    adapter, appOsh))

    finally:
        if shell:
            ## Close shell connection
            shell.closeClient()

    return OSHVResult