Cisco Meraki Monitoring

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

import com.santaba.agent.util.Settings
import groovy.json.JsonOutput
import groovy.json.JsonSlurper

// Set this variable to meraki API token.
def token = ""

// Optionally, create a list of organizations (e.g. [1243,2343,3564,4355])
// Setting this variable will only discover networks on those orgs.
def orgsAllowed = null

collectorCache = null
try {
    collectorCache = this.class.classLoader.loadClass("com.santaba.agent.util.script.ScriptCache").getCache()
}
catch (ClassNotFoundException ignored) {}
debug = false

orgs = cachedHttpGet(token, "/organizations")

orgs.each { org ->
    def orgId = org.id

    // Filter in only allowed orgs if it's defined.
    if (orgsAllowed != null) {
        if (!orgsAllowed.contains(orgId)) {
            return
        }
    }

    def orgName = org.name
    def networks = []
    def devices = []

    try {
        networks = cachedHttpGet(token, "/organizations/${orgId}/networks")
        devices = cachedHttpGet(token, "/organizations/${orgId}/devices")
    } catch (Exception error) {
            if (debug) println error.message
            return
    }

    networks.each { network ->
        def networkId = network.id

        // Check if this network has any devices and avoid reporting deviceless networks.
        def networkDevices  = devices.findAll{it.networkId == networkId}
        if (networkDevices.size() == 0) {
            return
        }

        def networkName = network.name
        def networkTags = network.tags
        def hostName = "${orgName.replaceAll('\\W', '')}.${networkName.replaceAll('\\W', '')}.invalid"
        def displayName = "Meraki Network: ${networkName}"

        println "${hostName}##${displayName}##meraki.org.name=${orgName}##meraki.org.id=${orgId}##meraki.api.key=${token}##meraki.network.id=${networkId}##meraki.network.name=${networkName}##meraki.network.tags=${networkTags}##meraki.network.type=${network.type}"
    }

    // Only add orgs if they have networks.
    if (networks.size() > 0) {
        println "${orgName.replaceAll('\\W', '')}.invalid##Meraki Org: ${orgName}##meraki.org.name=${orgName}##meraki.org.id=${orgId}##meraki.api.key=${token}"
    }
}

println "api.meraki.com##api.meraki.com##meraki.api.key=${token}"

return 0


def cachedHttpGet(String token, String endpoint, Map args=[:], String serviceUrl="https://api.meraki.com/api/v0", Integer expirySecs=600) {
    if (collectorCache) {
        def cacheKey = "CiscoMeraki.APICache:${token}-${composeUrl(serviceUrl, endpoint, args)}"

        LMDebugPrint("Trying cache for a recent answer to ${endpoint}")

        def cachedResponse = collectorCache.get(cacheKey)

        if (cachedResponse) {
            LMDebugPrint("Cached response found, returning ${cachedResponse.size()} bytes")
            return (new JsonSlurper()).parseText(cachedResponse)
        }
        else{
            LMDebugPrint("No cached response found.")
            Integer retryCount = 0

            while (retryCount < 5) {
                retryCount++
                // We are in the lock, lets get the data, update the cache and
                if(_cacheAcquireLock(cacheKey, 30)) {
                    try {
                        expirySecs = expirySecs * 1000 // Convert to ms.
                        cachedResponse = httpGet(token, endpoint, args, serviceUrl)
                        collectorCache.set(cacheKey, JsonOutput.toJson(cachedResponse), expirySecs)

                        return cachedResponse
                    }
                    finally {
                        _cacheReleaseLock(cacheKey)
                    }
                }
                else {
                    cachedResponse = collectorCache.get(cacheKey)
                    if (cachedResponse) {
                        return (new JsonSlurper()).parseText(cachedResponse)
                    }
                }

                sleep(1000) // Wait for the other thread to finish or time out.
            }
        }
    }

    else {
        return httpGet(token, endpoint, args, serviceUrl)
    }
}

boolean _cacheAcquireLock(String cacheKey, Integer timeOutSecs) {
    String lockKey = "${cacheKey}:Lock"
    String lockValue = collectorCache.get(lockKey)
    def now = (new Date()).getTime()
    if (lockValue == null) {
        lockValue = (now + timeOutSecs).toString()
        collectorCache.set(lockKey, lockValue, (timeOutSecs * 1000))
        return true
    }
    else {
        return false
    }
}

def _cacheReleaseLock(String cacheKey) {
    String lockKey = "${cacheKey}:Lock"
    collectorCache.remove(lockKey)
}

def httpGet(token, endpoint, Map args=[:], serviceUrl="https://api.meraki.com/api/v0") {
    def retryCount = 0

    while (true) {
        if (retryCount > 10) throw new Exception("Unable to get ${endpoint} after ${retryCount} retries, giving up")

        def request = rawHttpGet(token, endpoint, args, serviceUrl)
        def responseCode = request.getResponseCode()
        LMDebugPrint("Status code: ${responseCode}")

        if (responseCode == 200) {
            String content = request.content.text
            LMDebugPrint("Content length: ${content.size()} bytes")
            def payload = new JsonSlurper().parseText(content)

            String links = request.getHeaderField('link')
            if (links) {
                /* Unpack a header in this form:
                <https://nXXX.meraki.com/api/v1/organizations/00000000/devices?perPage=100&startingAfter=0000-0000-0000>; rel=first,
                <https://nXXX.meraki.com/api/v1/organizations/00000000/devices?endingBefore=XYZ-XYXX-XYZZ&perPage=100>; rel=prev,
                <https://nXX.meraki.com/api/v1/organizations/000000000/devices?endingBefore=ZZZZ-ZZZZ-ZZZZ&perPage=100>; rel=last
                 */
                links.split(',').each { link ->
                    def rel = link.split(';')[1].split('=')[1]

                    if (rel == 'next') {
                        def nextEndpoint = link.split(';')[0].strip()[1..-2]
                        sleep(200) // Sleep 1/6th of a second to avoid triggering the throttling.
                        payload += httpGet(token, "", [:], nextEndpoint)
                    }
                }
            }

            return payload
        }
        else if (responseCode == 429) {
            def retryIn = request.getHeaderField('Retry-After')

            if (retryIn == null) retryIn = 5
            else retryIn = retryIn.toInteger()

            LMDebugPrint("Sleeping and retrying in ${retryIn} ms after recieving a 429 response")
            sleep(retryIn * 1000)
        }
        else {
            throw new Exception("Server return HTTP code ${responseCode} from ${endpoint}")
        }
        retryCount++
    }
}



static String composeUrl(String serviceUrl, String endpoint, Map args) {
    def url = serviceUrl+endpoint

    if (args) {
        def encodedArgs = []
        args.each{ k,v ->
            encodedArgs << "${k}=${URLEncoder.encode(v.toString(), "UTF-8")}"
        }
        url += "?${encodedArgs.join('&')}"
    }
    return url
}

def rawHttpGet(String token, String endpoint, Map args=[:],serviceUrl="https://api.meraki.com/api/v0") {
    def headers = ["X-Cisco-Meraki-API-Key": token.toString(),
                   "Accept": "application/json"]

    url = composeUrl(serviceUrl, endpoint, args)

    def request = null
    def proxyInfo = getProxyInfo()

    if (proxyInfo) {
        request = url.toURL().openConnection(proxyInfo)
    }
    else {
        request = url.toURL().openConnection()
    }

    headers.each { request.addRequestProperty(it.key, it.value)}
    LMDebugPrint("GET ${url}")

    return request
}

def getProxyInfo() {
    if (Settings.getSetting("proxy.enable").toBoolean()) {
        return new Proxy(Proxy.Type.HTTP,
                new InetSocketAddress(Settings.getSetting("proxy.host"), Settings.getSetting("proxy.port")?.toInteger()))
    }

    return null
}

def LMDebugPrint(message) {
    if (debug) {
        println(message.toString())
    }
}