Ruckus One AP Monitoring

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

import com.santaba.agent.groovy.utils.GroovyScriptHelper as GSH
import com.logicmonitor.mod.Snippets
import com.santaba.agent.AgentVersion
import java.text.DecimalFormat
import groovy.json.JsonOutput
import groovy.json.JsonSlurper

// To run in debug mode, set to true
Boolean debug = false

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

// Credentials Check
if (!props.get("ruckus.one.tenant.id") || !props.get("ruckus.one.client.id") || !props.get("ruckus.one.client.key")) {
    throw new Exception("Must provide 'ruckus.one.tenant.id', 'ruckus.one.client.id', and 'ruckus.one.client.key' to run this script. Verify necessary credentials have been provided.")
}

// Optional properties
def rootFolder = props.get("root.folder.name", "Ruckus One")  // root folder can be nested, i.e. 'site1/subfolder1'
Boolean skipDeviceDedupe = props.get("skip.device.dedupe", "false").toBoolean()
String hostnameSource = props.get("hostname.source", "")?.toLowerCase()?.trim()

// Get region & tenant ID
def region = props.get("ruckus.one.region") ?: "api.ruckus.cloud"
def tenantId     = props.get("ruckus.one.tenant.id")

// Cache context
def logCacheContext = "${tenantId}::ruckus-one-ap"

def modLoader   = GSH.getInstance(GroovySystem.version).getScript("Snippets", Snippets.getLoader()).withBinding(getBinding())
def lmEmit      = modLoader.load("lm.emit", "1.1")
def lmDebug     = modLoader.load("lm.debug", "1.0").debugSnippetFactory(out, debug)
def http        = modLoader.load("proto.http", "0").httpSnippetFactory(props)
def cache       = modLoader.load("lm.cache", "0").cacheSnippetFactory(lmDebug, logCacheContext)
def ruckusOneAp = modLoader.load("ruckus.one.ap", "0").create(props, lmDebug, cache, http)

// Only initialize lmApi snippet class if customer has not opted out
def lmApi
if (!skipDeviceDedupe) {
    lmApi = modLoader.load("lm.api", "0").lmApiSnippetFactory(props, http, lmDebug)
}

// Get information about devices that already exist in LM portal
List fields = ["name", "currentCollectorId", "displayName"]
Map args = ["size": 1000, "fields": fields.join(",")]
def lmDevices
// But first determine if the portal size is within a range that allows us to get all devices at once
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 // Allow range 30-120 sec if configured; default to 60 sec

    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)
    }
}

// Get all AP information for tenant
def apsEndpoint = "venues/aps/query"
def apsEndpointBody = '{"pageSize": 10000 , "fields": ["serialNumber","venueId","model","macAddress","firmwareVersion", "name", "networkStatus.ipAddress" ] }'
def apsResponseData = null
if(debug){
    apsResponseData = cache.cacheGet(apsEndpoint)
} else {
    apsResponseData = ruckusOneAp.requestDataFromAPI("POST", apsEndpoint, apsEndpointBody)
}
lmDebug.LMDebugPrint("\nResponse Data from ${apsEndpoint}:\n${apsResponseData}\n")
def apData = ruckusOneAp.slurper.parseText(apsResponseData)
lmDebug.LMDebugPrint("AP Data: ${apData}")

// Get venue ID to name mappings
def venueEndpoint = "venues/query"
def venueEndpointBody = '{"pageSize": 10000, "fields": ["id","name"] }'
def venueResponseData = null
if(debug){
    venueResponseData = cache.cacheGet(venueEndpoint)
} else {
    venueResponseData = ruckusOneAp.requestDataFromAPI("POST", venueEndpoint, venueEndpointBody)
}
lmDebug.LMDebugPrint("\nResponse Data from ${apsEndpoint}:\n${venueResponseData}\n")
venueResponseData = ruckusOneAp.slurper.parseText(venueResponseData)
Map<String,String> venueIdToNameMap = venueResponseData?.data?.collectEntries { venue ->
    [(venue.id): venue.name]
}
lmDebug.LMDebugPrint("venueIdToNameMap: ${venueIdToNameMap}")

// Get tenant ID and name
def tenantEndpoint = "tenants/self"
def tenantResponseData = ruckusOneAp.requestDataFromAPI("GET", tenantEndpoint)
lmDebug.LMDebugPrint("\nResponse Data from ${tenantEndpoint}:\n${tenantResponseData}\n")
tenantResponseData = ruckusOneAp.slurper.parseText(tenantResponseData)
def responseTenantId = tenantResponseData?.id
def responseTenantName = tenantResponseData?.name
lmDebug.LMDebugPrint("Tenant Info: 'id'=${responseTenantId}, 'name'=${responseTenantName}")

// Fail safe
if(responseTenantId != tenantId) {
    throw new Exception("Tenant ID provided in credentials (${tenantId}) does not match tenant ID retrieved from API (${responseTenantId}). Verify credentials and try again.")
}

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 display names found within LogicMonitor portal wherein hostname in LM does not match hostname in Netscan output.  Refer to documentation for how to resolve name collisions using 'hostname.source' netscan property.",
        "total" : 0,
        "resources" : []
]

// Loop through data to build device map with proper keys
apData?.data?.each{ device ->

    String displayName = device.name
    Integer collectorId

    // Check for existing device in LM portal with this displayName; set to false initially and update to true when dupe found
    def deviceMatch = false
    // If customer has opted out of device deduplication checks, we skip the lookups where we determine if a match exists and proceed as false
    if (!skipDeviceDedupe) {
        if (pathFlag == "ind") {
            deviceMatch = lmApi.findPortalDevice(displayName, args)
        }
        else if (pathFlag == "all") {
            deviceMatch = lmApi.checkExistingDevices(displayName, lmDevices)
        }
    }

    if (deviceMatch) {
        // 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 ip = device?.networkStatus?.ipAddress // ip from the endpoint data
        if (ip != deviceMatch.name) {
            def collisionInfo = [
                    (displayName) : [
                            "Netscan" : [
                                    "hostname"    : ip
                            ],
                            "LM" : [
                                    "hostname"    : deviceMatch.name,
                                    "collectorId" : deviceMatch.currentCollectorId
                            ],
                            "Resolved" : false
                    ]
            ]

            // If user specified to use LM hostname on display name match, update hostname variable accordingly
            // and flag it as no longer a match since we have resolved the collision with user's input
            if (hostnameSource == "lm" || hostnameSource == "logicmonitor") {
                ip = deviceMatch.name
                collectorId = deviceMatch.currentCollectorId
                deviceMatch = false
                collisionInfo[displayName]["Resolved"] = true
            }
            // If user specified to use netscan data for hostname, update the display name to make it unique
            // and flag it as no longer a match since we have resolved the collision with user's input
            else if (hostnameSource == "netscan") {
                // Update the resolved status before we change the displayName
                collisionInfo[displayName]["Resolved"] = true
                displayName = "${displayName} - ${ip}"
                deviceMatch = false
            }

            duplicateResources["resources"].add(collisionInfo)
        }
    }

    // Initialize groupName and assign value based on whether a proper venue name has been provided via CSV
    List<String> groupName = ["${rootFolder}/${responseTenantName}/${venueIdToNameMap[device.venueId]}"]

    def hostPropsToEmit = [
        "ruckus.one.region"    : region,                                // region, defaults to "api.ruckus.cloud" if not set
        "ruckus.one.tenant.name": responseTenantName,                   // tenant name
        "ruckus.one.tenant.id" : responseTenantId,                      // tenant
        "ruckus.one.client.id" : props.get("ruckus.one.client.id"),     // credentials
        "ruckus.one.client.key": props.get("ruckus.one.client.key"),    // credentials
        "ruckus.one.venue.id"  : device.venueId,                        // used to filter data by venue
        "ruckus.one.venue.name": venueIdToNameMap[device.venueId],      // venue name
        "ruckus.one.serial"    : device.serialNumber.toString(),        // used to filter data by AP serial number
    ]

    // Build resource map
    Map resource = [
            "hostname"    : "${device.networkStatus.ipAddress}",   // String
            "displayname" : device.name,            // String
            "hostProps"   : hostPropsToEmit,        // Map<String, String>
            "groupName"   : groupName,              // List<String>
            "collectorId" : collectorId             // Integer
    ]

    // Only add the collectorId field to resource map if we found a collector ID above
    if (collectorId) {
        resource["collectorId"] = collectorId
        duplicateResources["resources"][displayName]["Netscan"][0]["collectorId"] = collectorId
    }

    if (!deviceMatch) {
        resources.add(resource)
    }
}

// Output validated data in JSON format
lmEmit.resource(resources, debug)

// Report devices that already exist in LM via log file named after root folder
if (duplicateResources["resources"].size() > 0) {
    def netscanDupLog = new File("../logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json")
    new File(netscanDupLog.getParent()).mkdirs()
    duplicateResources["total"] = duplicateResources["resources"].size()
    def json = JsonOutput.prettyPrint(JsonOutput.toJson(duplicateResources))
    netscanDupLog.write(json)
    if (hostnameSource) {
        lmDebug.LMDebug("${duplicateResources["resources"].size()} devices found that were resolved with hostname.source=${hostnameSource} in netscan output.  See LogicMonitor/Agent/logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json for details.")
    }
    else {
        lmDebug.LMDebug("${duplicateResources["resources"].size()} devices found that were not reported in netscan output.  See LogicMonitor/Agent/logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json for details.")
    }
}

return 0