Nutanix Prism 中央監視

/*******************************************************************************
 * © 2007-2025 - LogicMonitor, Inc. All rights reserved.
 ******************************************************************************/

import com.santaba.agent.groovy.utils.GroovyScriptHelper as GSH
import com.logicmonitor.mod.Snippets
import groovy.json.JsonSlurper

Boolean debug = false
Boolean log = false

// Set props object based on whether or not we are running inside a netscan or debug console
def props
def prismCentralHost
try {
    hostProps.get("system.hostname")
    props = hostProps
    prismCentralHost = props.get("nutanix.prism.central.host", props.get("system.hostname", ""))
    debug = true  // set debug to true so that we can ensure we do not print sensitive properties
}
catch (MissingPropertyException) {
    props = netscanProps
    prismCentralHost = props.get("nutanix.prism.central.host", "")
}


def modLoader = GSH.getInstance(GroovySystem.version).getScript("Snippets", Snippets.getLoader()).withBinding(getBinding())
def lmDebugSnip = modLoader.load("lm.debug", "1")
def lmDebug = lmDebugSnip.debugSnippetFactory(out, debug, log, "Nutanix_PrismCentral_Netscan")
def emit = modLoader.load("lm.emit", "1")
def httpSnip = modLoader.load("proto.http", "0")
def http = httpSnip.httpSnippetFactory(props)
def nutanixPrismCentralSnip = modLoader.load("nutanix.prism.central", "0")
def nutanixPrismCentral = nutanixPrismCentralSnip.nutanixPrismCentralSnippetFactory(props, lmDebug, http)

// Configuration options
def rootFolder = props.get("rootFolder") ?: "Nutanix Prism Central Resources"
Boolean skipDeviceDedupe = props.get("skip.device.dedupe", "false").toBoolean()
String hostnameSource = props.get("hostname.source", "")?.toLowerCase()?.trim()

// Initialize LM API for device deduplication if not skipped
def lmApi
if (!skipDeviceDedupe) {
    def lmApiSnippet = modLoader.load("lm.api", "0")
    lmApi = lmApiSnippet.lmApiSnippetFactory(props, http, lmDebug)
}

// Get information about devices that already exist in LM portal
List fields = ["name", "currentCollectorId", "displayName", "id", "customProperties"]
Map args = ["size": 1000, "fields": fields.join(",")]
def lmDevices
def pathFlag, portalInfo, timeLimitSec, timeLimitMs
if (!skipDeviceDedupe) {
    portalInfo = lmApi.apiCallInfo("Devices", args)
    timeLimitSec = props.get("lmapi.timelimit.sec", "60").toInteger()
    timeLimitMs = (timeLimitSec) ? Math.min(Math.max(timeLimitSec, 30), 120) * 1000 : 60000

    if (portalInfo.timeEstimateMs > timeLimitMs) {
        lmDebug.LMDebugPrint("Estimate indicates LM API calls would take longer than time limit configured. Proceeding with individual queries by display name for each device to add.")
        lmDebug.LMDebugPrint("\t${portalInfo}\n\tNOTE: Time limit is set to ${timeLimitSec} seconds. Adjust this limit by setting the property lmapi.timelimit.sec. Max 120 seconds, min 30 seconds.")
        pathFlag = "ind"
    } else {
        lmDebug.LMDebugPrint("Response time indicates LM API calls will complete in a reasonable time range. Proceeding to collect info on all devices to cross reference and prevent duplicate device creation.\n\t${portalInfo}")
        pathFlag = "all"
        lmDevices = lmApi.getPortalDevices(args)
    }
}

List<Map> resources = []

def now = new Date()
def dateFormat = "yyyy-MM-dd'T'HH:mm:ss.s z"
TimeZone tz = TimeZone.getDefault()
Map duplicateResources = [
        "date"     : now.format(dateFormat, tz),
        "message"  : "Duplicate device names and display names, keyed by display name that would be assigned by the netscan, found within LogicMonitor portal. Refer to documentation for how to resolve name collisions using 'hostname.source' netscan property.",
        "total"    : 0,
        "resources": []
]

// Get all hosts data with pagination
def hostsData = nutanixPrismCentral.httpGet("clustermgmt/v4.0/config/hosts?\$limit=100")
def allHosts = []
def hostsCurrentPage = 0
def hostsPageSize = 100

if (hostsData && hostsData.data) {
    allHosts.addAll(hostsData.data)
    lmDebug.LMDebugPrint("Hosts first page: Found ${hostsData.data.size()} hosts")

    // Check if there are more pages to process
    def hostsHasMore = hostsData.metadata?.links?.find { it.rel == "next" } != null

    if (hostsHasMore) {
        lmDebug.LMDebugPrint("Hosts pagination detected. Total available: ${hostsData.totalAvailableResults ?: 'unknown'}")

        // Continue fetching remaining pages
        while (hostsHasMore) {
            hostsCurrentPage++
            lmDebug.LMDebugPrint("Fetching hosts page ${hostsCurrentPage + 1}...")

            def hostsPageData = nutanixPrismCentral.httpGet("clustermgmt/v4.0/config/hosts?\$limit=${hostsPageSize}&\$page=${hostsCurrentPage}")

            if (hostsPageData && hostsPageData.data && hostsPageData.data.size() > 0) {
                allHosts.addAll(hostsPageData.data)
                lmDebug.LMDebugPrint("Hosts page ${hostsCurrentPage + 1}: Found ${hostsPageData.data.size()} hosts")

                // Check if there's a next page
                hostsHasMore = hostsPageData.metadata?.links?.find { it.rel == "next" } != null
            } else {
                lmDebug.LMDebugPrint("No more hosts data found, stopping pagination")
                hostsHasMore = false
            }

            // Safety check to prevent infinite loops
            if (hostsCurrentPage > 50) {
                lmDebug.LMDebugPrint("Reached maximum hosts page limit (50), stopping pagination")
                break
            }
        }
    }
}

lmDebug.LMDebugPrint("Total hosts discovered: ${allHosts.size()}")

// Process each host
allHosts.each { host ->

    def hostExtId = host.extId
    def hostName = host.hostName
    def serial = host.blockSerial

    lmDebug.LMDebug("Processing host: ${hostName} (extId: ${hostExtId})")

    if (!hostExtId || !hostName) {
        lmDebug.LMDebug("ERROR: Host missing required fields (extId: ${hostExtId}, name: ${hostName}), skipping")
        return
    }

    String displayName = hostName
    def hostname = hostName
    def ip = hostName

    // Try to get IP from hypervisor external address
    if (host.hypervisor?.externalAddress?.ipv4?.value) {
        ip = host.hypervisor.externalAddress.ipv4.value
        hostname = ip

        // Try reverse DNS lookup
        try {
            def reverseDnsName = InetAddress.getByName(ip)?.getHostName()
            if (reverseDnsName && reverseDnsName != ip) {
                hostname = reverseDnsName
            }
        } catch (Exception e) {
            lmDebug.LMDebug("DEBUG: Failed to resolve reverse DNS for ${ip}: ${e.message}")
        }
    }

    // Check for existing device in LM portal
    def deviceMatch = false
    if (!skipDeviceDedupe) {
        if (pathFlag == "ind") {
            deviceMatch = lmApi.findPortalDevice(displayName, args)
        } else if (pathFlag == "all") {
            deviceMatch = lmApi.checkExistingDevices(displayName, lmDevices)
        }
    }

    if (deviceMatch) {
        if (hostname != deviceMatch?.name) {
            // Log duplicates that would cause additional devices to be created; unless these entries are resolved, they will not be added to resources for netscan output
            def collisionInfo = [
                    (displayName): [
                            "Netscan" : [
                                    "hostname"   : hostname,
                                    "displayName": displayName
                            ],
                            "LM"      : [
                                    "hostname"   : deviceMatch?.name,
                                    "collectorId": deviceMatch?.currentCollectorId,
                                    "displayName": deviceMatch?.displayName
                            ],
                            "Resolved": false
                    ]
            ]

            // Resolve hostname collision based on user preference
            if (hostnameSource == "lm" || hostnameSource == "logicmonitor") {
                hostname = deviceMatch?.name
                displayName = deviceMatch?.displayName
                deviceMatch = false
                if (collisionInfo && collisionInfo[displayName]) {
                    collisionInfo[displayName]["Resolved"] = true
                }
            } else if (hostnameSource == "netscan") {
                if (collisionInfo && collisionInfo[displayName]) {
                    collisionInfo[displayName]["Resolved"] = true
                }
                displayName = "${displayName} - ${ip}"
                deviceMatch = false
            }

            if (collisionInfo) {
                duplicateResources["resources"].add(collisionInfo)
            }
        }
        // Don't worry about matches where the hostname values are the same
        // These will update via normal NetScan processing and should be ignored
        else {
            deviceMatch = false
        }
    }
    // Determine device group based on cluster
    def deviceGroups = []
    deviceGroups << "${rootFolder}"

    // Resource host properties
    Map hostProps = [
            "system.categories"         : "Nutanix_Hypervisor",
            "nutanix.prism.central.host": prismCentralHost,
            "nutanix.prism.central.user": props.get("nutanix.prism.central.user"),
            "nutanix.prism.central.pass": props.get("nutanix.prism.central.pass"),
            "nutanix.hypervisor.serial" : serial

    ]


    def resource = [
            "hostname"   : hostname,
            "displayname": displayName,
            "hostProps"  : hostProps,
            "groupName"  : deviceGroups
    ]

    lmDebug.LMDebugPrint("Adding host: ${displayName} (${hostname})")
    if (!deviceMatch) resources.add(resource)
}

// Get Prism Central resource information
lmDebug.LMDebugPrint("Fetching Prism Central resource...")
def domainManagerData = nutanixPrismCentral.httpGet("prism/v4.0/config/domain-managers")

if (domainManagerData && domainManagerData.data && domainManagerData.data.size() > 0) {
    def domainManager = domainManagerData.data[0]

    lmDebug.LMDebugPrint("Processing Prism Central resource")

    // Perform nslookup on nutanix.prism.central.host
    String prismHostForLookup = prismCentralHost
    String prismHostIP = null
    String prismHostDNS = prismCentralHost

    try {
        def inetAddress = InetAddress.getByName(prismHostForLookup)
        prismHostIP = inetAddress.getHostAddress()
        prismHostDNS = inetAddress.getHostName()

        lmDebug.LMDebug("DEBUG: DNS lookup for ${prismHostForLookup}: IP=${prismHostIP}, DNS=${prismHostDNS}")
    } catch (Exception e) {
        lmDebug.LMDebug("ERROR: Failed to resolve ${prismHostForLookup}: ${e.message}")
        // If lookup fails, use the original value
        prismHostIP = prismCentralHost
        prismHostDNS = prismCentralHost
    }

    // Determine hostname based on nslookup result
    String pcHostname = prismHostIP

    // Determine displayname from config.name
    String pcConfigName = domainManager.config?.name ?: "Unnamed"
    String pcDisplayName = pcConfigName

    // If config.name is "Unnamed", use DNS name
    if (pcConfigName == "Unnamed") {
        pcDisplayName = prismHostDNS
        lmDebug.LMDebug("DEBUG: Config name is 'Unnamed', using DNS name: ${pcDisplayName}")
    }

    // Check for existing device in LM portal
    def pcDeviceMatch = false
    if (!skipDeviceDedupe) {
        if (pathFlag == "ind") {
            pcDeviceMatch = lmApi.findPortalDevice(pcDisplayName, args)
        } else if (pathFlag == "all") {
            pcDeviceMatch = lmApi.checkExistingDevices(pcDisplayName, lmDevices)
        }
    }

    if (pcDeviceMatch) {
        if (pcHostname != pcDeviceMatch?.name) {
            // Log duplicates that would cause additional devices to be created; unless these entries are resolved, they will not be added to resources for netscan output
            def pcCollisionInfo = [
                    (pcDisplayName): [
                            "Netscan" : [
                                    "hostname"   : pcHostname,
                                    "displayName": pcDisplayName
                            ],
                            "LM"      : [
                                    "hostname"   : pcDeviceMatch?.name,
                                    "collectorId": pcDeviceMatch?.currentCollectorId,
                                    "displayName": pcDeviceMatch?.displayName
                            ],
                            "Resolved": false
                    ]
            ]

            // Resolve hostname collision based on user preference
            if (hostnameSource == "lm" || hostnameSource == "logicmonitor") {
                pcHostname = pcDeviceMatch?.name
                pcDisplayName = pcDeviceMatch?.displayName
                pcDeviceMatch = false

                if (pcCollisionInfo && pcCollisionInfo[pcDisplayName]) {
                    pcCollisionInfo[pcDisplayName]["Resolved"] = true
                }
            } else if (hostnameSource == "netscan") {
                pcDisplayName = "${pcDisplayName} - ${pcHostname}"
                pcDeviceMatch = false

                if (pcCollisionInfo && pcCollisionInfo[pcDisplayName]) {
                    pcCollisionInfo[pcDisplayName]["Resolved"] = true
                }
            }

            if (pcCollisionInfo) {
                duplicateResources["resources"].add(pcCollisionInfo)
            }
        }
        // Don't worry about matches where the hostname values are the same
        // These will update via normal netscan processing and should be ignored
        else {
            pcDeviceMatch = false
        }
    }

    if (!pcDeviceMatch) {
        // Prism Central resource properties
        Map pcHostProps = [
                "system.categories"         : "Nutanix_PrismCentral",
                "nutanix.prism.central.user": props.get("nutanix.prism.central.user"),
                "nutanix.prism.central.pass": props.get("nutanix.prism.central.pass")
        ]

        def pcDeviceGroups = []
        pcDeviceGroups << "${rootFolder}"

        def pcResource = [
                "hostname"   : pcHostname,
                "displayname": pcDisplayName,
                "hostProps"  : pcHostProps,
                "groupName"  : pcDeviceGroups
        ]

        lmDebug.LMDebugPrint("Adding Prism Central resource: ${pcDisplayName} (${pcHostname})")
        resources.add(pcResource)
    } else {
        lmDebug.LMDebug("DEBUG: Skipping Prism Central resource - already exists in portal")
    }
} else {
    lmDebug.LMDebug("WARNING: No Prism Central domain manager data found")
}

lmDebug.LMDebugPrint("Duplicate Resources:")
if (duplicateResources && duplicateResources.resources) {
    duplicateResources.resources.each { collisionInfo ->
        if (collisionInfo) {
            collisionInfo.each { key, value ->
                lmDebug.LMDebugPrint("\t${key}: ${value}")
            }
        }
    }
}

lmDebug.LMDebugPrint("Summary: Found ${resources.size()} resource(s) to add (including Prism Central)")
if ((resources.size()) == 0) {
    lmDebug.LMDebugPrint("No resources to add. Exiting netscan.")
} else {
    emit.resource(resources, debug)
}

return 0