src/com/mirantis/mk/Salt.groovy

package com.mirantis.mk

/**
 * Salt functions
 *
*/

/**
 * Salt connection and context parameters
 *
 * @param url                 Salt API server URL
 * @param credentialsID       ID of credentials store entry
 */
def connection(url, credentialsId = "salt") {
    def common = new com.mirantis.mk.Common()
    params = [
        "url": url,
        "credentialsId": credentialsId,
        "authToken": null,
        "creds": common.getCredentials(credentialsId)
    ]
    params["authToken"] = saltLogin(params)

    return params
}

/**
 * Login to Salt API, return auth token
 *
 * @param master   Salt connection object
 */
def saltLogin(master) {
    def http = new com.mirantis.mk.Http()
    data = [
        'username': master.creds.username,
        'password': master.creds.password.toString(),
        'eauth': 'pam'
    ]
    authToken = http.restGet(master, '/login', data)['return'][0]['token']
    return authToken
}

/**
 * Run action using Salt API
 *
 * @param master   Salt connection object
 * @param client   Client type
 * @param target   Target specification, eg. for compound matches by Pillar
 *                 data: ['expression': 'I@openssh:server', 'type': 'compound'])
 * @param function Function to execute (eg. "state.sls")
 * @param batch
 * @param args     Additional arguments to function
 * @param kwargs   Additional key-value arguments to function
 */
@NonCPS
def runSaltCommand(master, client, target, function, batch = null, args = null, kwargs = null) {
    def http = new com.mirantis.mk.Http()

    data = [
        'tgt': target.expression,
        'fun': function,
        'client': client,
        'expr_form': target.type,
    ]

    if (batch == true) {
        data['batch'] = "local_batch"
    }

    if (args) {
        data['arg'] = args
    }

    if (kwargs) {
        data['kwarg'] = kwargs
    }

    headers = [
      'X-Auth-Token': "${master.authToken}"
    ]

    return http.sendHttpPostRequest("${master.url}/", data, headers)
}

/**
 * Return pillar for given master and target
 * @param master Salt connection object
 * @param target Get pillar target
 * @param pillar pillar name (optional)
 * @return output of salt command
 */
def getPillar(master, target, pillar = null) {
    if (pillar != null) {
        return runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'pillar.get', null, [pillar.replace('.', ':')])
    } else {
        return runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'pillar.data')
    }
}

/**
 * Return grain for given master and target
 * @param master Salt connection object
 * @param target Get grain target
 * @param grain grain name (optional)
 * @return output of salt command
 */
def getGrain(master, target, grain = null) {
    if(grain != null) {
        return runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'grain.item', null, [grain])
    } else {
        return runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'grain.items')
    }
}

/**
 * Enforces state on given master and target
 * @param master Salt connection object
 * @param target State enforcing target
 * @param state Salt state
 * @param output print output (optional, default true)
 * @param failOnError throw exception on salt state result:false (optional, default true)
 * @return output of salt command
 */
def enforceState(master, target, state, output = true, failOnError = true) {
    def common = new com.mirantis.mk.Common()
    def run_states

    if (state instanceof String) {
        run_states = state
    } else {
        run_states = state.join(',')
    }

    common.infoMsg("Enforcing state ${run_states} on ${target}")

    def out = runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'state.sls', null, [run_states])

    try {
        checkResult(out, failOnError)
    } finally {
        if (output == true) {
            printSaltStateResult(out)
        }
    }
    return out
}

/**
 * Run command on salt minion (salt cmd.run wrapper)
 * @param master Salt connection object
 * @param target Get pillar target
 * @param cmd command
 * @return output of salt command
 */
def cmdRun(master, target, cmd) {
    def common = new com.mirantis.mk.Common()

    common.infoMsg("Running command ${cmd} on ${target}")

    return runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'cmd.run', null, [cmd])
}

/**
 * Perform complete salt sync between master and target
 * @param master Salt connection object
 * @param target Get pillar target
 * @return output of salt command
 */
def syncAll(master, target) {
    return runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'saltutil.sync_all')
}

/**
 * Enforce highstate on given targets
 * @param master Salt connection object
 * @param target Highstate enforcing target
 * @param output print output (optional, default true)
 * @param failOnError throw exception on salt state result:false (optional, default true)
 * @return output of salt command
 */
def enforceHighstate(master, target, output = false, failOnError = true) {
    def out = runSaltCommand(master, 'local', ['expression': target, 'type': 'compound'], 'state.highstate')
    try {
        checkResult(out, failOnError)
    } finally {
        if (output == true) {
            printSaltStateResult(out)
        }
    }
    return out
}

/**
 * Generates node key using key.gen_accept call
 * @param master Salt connection object
 * @param target Key generating target
 * @param host Key generating host
 * @param keysize generated key size (optional, default 4096)
 * @return output of salt command
 */
def generateNodeKey(master, target, host, keysize = 4096) {
    return runSaltCommand(master, 'wheel', target, 'key.gen_accept', [host], ['keysize': keysize])
}

/**
 * Generates node reclass metadata 
 * @param master Salt connection object
 * @param target Metadata generating target
 * @param host Metadata generating host
 * @param classes Reclass classes
 * @param parameters Reclass parameters
 * @return output of salt command
 */
def generateNodeMetadata(master, target, host, classes, parameters) {
    return runSaltCommand(master, 'local', target, 'reclass.node_create', [host, '_generated'], ['classes': classes, 'parameters': parameters])
}

/**
 * Run salt orchestrate on given targets
 * @param master Salt connection object
 * @param target Orchestration target
 * @param orchestrate Salt orchestrate params
 * @return output of salt command
 */
def orchestrateSystem(master, target, orchestrate) {
    return runSaltCommand(master, 'runner', target, 'state.orchestrate', [orchestrate])
}

/**
 * Run salt process step
 * @param master Salt connection object
 * @param tgt Salt process step target
 * @param fun Salt process step function
 * @param arg process step arguments (optional, default [])
 * @param batch using batch (optional, default false)
 * @param output print output (optional, default false)
 * @return output of salt command
 */
def runSaltProcessStep(master, tgt, fun, arg = [], batch = null, output = false) {
    def common = new com.mirantis.mk.Common()
    def out

    common.infoMsg("Running step ${fun} on ${tgt}")

    if (batch == true) {
        out = runSaltCommand(master, 'local_batch', ['expression': tgt, 'type': 'compound'], fun, String.valueOf(batch), arg)
    } else {
        out = runSaltCommand(master, 'local', ['expression': tgt, 'type': 'compound'], fun, batch, arg)
    }

    if (output == true) {
        printSaltCommandResult(out)
    }
}

/**
 * Check result for errors and throw exception if any found
 *
 * @param result    Parsed response of Salt API
 * @param failOnError Do you want to throw exception if salt-call fails
 */
def checkResult(result, failOnError = true) {
    def common = new com.mirantis.mk.Common()
    if(result['return']){
        for (int i=0;i<result['return'].size();i++) {
            def entry = result['return'][i]
            if (!entry) {
                if (failOnError) {
                    throw new Exception("Salt API returned empty response: ${result}")
                } else {
                    common.errorMsg("Salt API returned empty response: ${result}")
                }
            }
            for (int j=0;j<entry.size();j++) {
                def nodeKey = entry.keySet()[j]
                def node=entry[nodeKey]
                for (int k=0;k<node.size();k++) {
                    def resource;
                    def resKey;
                    if(node instanceof Map){
                        resKey = node.keySet()[k]
                    }else if(node instanceof List){
                        resKey = k
                    }
                    resource = node[resKey]
                    common.errorMsg("Checking resource: ${resource}")
                    if(resource instanceof String || !resource["result"] || (resource["result"] instanceof String && resource["result"] != "true")){
                        if (failOnError) {
                            throw new Exception("Salt state on node ${nodeKey} failed: ${resource}. State output: ${node}")
                        } else {
                            common.errorMsg("Salt state on node ${nodeKey} failed: ${resource}. State output: ${node}")
                        }
                    }
                }
            }
        }
    }else{
        common.errorMsg("Salt result hasn't return attribute! Result: ${result}")
    }
}

/**
 * Print Salt state run results in human-friendly form
 *
 * @param result        Parsed response of Salt API
 * @param onlyChanges   If true (default), print only changed resources
 *                      parsing
 */
def printSaltStateResult(result, onlyChanges = true) {
    def common = new com.mirantis.mk.Common()
    def out = [:]
    if(result['return']){
        for (int i=0; i<result['return'].size(); i++) {
            def entry = result['return'][i]
            for (int j=0; j<entry.size(); j++) {
                common.errorMsg("Entry is: ${entry}")
                def nodeKey = entry.keySet()[j]
                def node=entry[nodeKey]
                out[nodeKey] = [:]
                if(node instanceof Iterable){
                    for (int k=0; k<node.size(); k++) {
                        def resource;
                        def resKey;
                        if(node instanceof Map){
                            resKey = node.keySet()[k]
                        }else if(node instanceof List){
                            resKey=k
                        }
                        resource = node[resKey]
                        if (resource instanceof String) {
                            //ORIGINAL??out[node.key] = node.value
                            out[nodeKey][resKey] = resource
                        } else if (resource.result.toString().toBoolean() == false || resource.changes || onlyChanges == false) {
                            out[nodeKey][resKey] = resource.value
                        }
                    }
                } else {
                    out[nodeKey] = node.toString();
                }
            }
        }

        for (int i=0; i<out.size(); i++) {
            def nodeKey = out.keySet()[i]
            def node=out[nodeKey]
            if (node) {
                println "Node ${nodeKey} changes:"
                print new groovy.json.JsonBuilder(node).toPrettyString().replace('\\n', System.getProperty('line.separator'))
            } else {
                println "No changes for node ${nodeKey}"
            }
        }
    }else{
        common.errorMsg("Salt result hasn't return attribute! Result: ${result}")
    }
}

/**
 * Print Salt state run results in human-friendly form
 *
 * @param result        Parsed response of Salt API
 */
def printSaltCommandResult(result) {
    def common = new com.mirantis.mk.Common()
    def out = [:]
    if(result['return']){
        for (int i=0; i<result['return'].size(); i++) {
            def entry = result['return'][i]
            for (int j=0; j<entry.size(); j++) {
                common.errorMsg("Entry is: ${entry}")
                def nodeKey = entry.keySet()[j]
                def node=entry[nodeKey]
                out[nodeKey] = [:]
                if(node instanceof Iterable){
                    for (int k=0; k<node.size(); k++) {
                        def resource;
                        def resKey;
                        if(node instanceof Map){
                            resKey = node.keySet()[k]
                        }else if(node instanceof List){
                            resKey=k
                        }
                        resource = node[resKey]
                        //ORIGINAL??out[node.key] = node.value
                        out[nodeKey][resKey] = resource
                    }
                } else {
                    out[nodeKey] = node.toString();
                }
            }
        }

        for (int i=0; i<out.size(); i++) {
            def nodeKey = out.keySet()[i]
            def node = out[nodeKey]
            if (node) {
                common.infoMsg("Node ${nodeKey} changes:")
                common.infoMsg(new groovy.json.JsonBuilder(node).toPrettyString())
            } else {
                common.infoMsg("No changes for node ${nodeKey}")
            }
        }
    }else{
        common.errorMsg("Salt result hasn't return attribute! Result: ${result}")
    }
}