sync->async for John Heeter's codementor task

file_1.js

const exec = require('child_process').exec
const spawn = require('child_process').spawn
const dockerMachine = require('dockermachine')

machine = {
    cmd(cmd, cb) {
        return exec('docker-machine ' + cmd, (error, output) => {
            if (error) {
                console.log("something Broke:" + error)
                return "something Broke: " + error
            }

            cb(output.toString().trim());
        });
    },
    spawn(cmd) {
        return spawn('docker-machine', cmd)
    },
    ip(name, cb) {
        return machine.cmd('ip ' + name, cb)
    },
    ssh(name, cmd, cb) {
        return machine.cmd('ssh ' + name + ' sudo ' + cmd, cb)
    },
    docker: {
        swarm(name, cmd, cb) {
            return machine.ssh(name, 'docker swarm ' + cmd, cb)
        },
        node(name, cmd, cb) {
            return machine.ssh(name, 'docker node ' + cmd, cb)
        },
        service(name, cmd, cb) {
            return machine.ssh(name, 'docker service ' + cmd, cb)
        }

    },
    list(cb) {
        // return dockerMachine.list({ inspect: true }, (err, machines) => {
        //     if (err) {
        //         console.log(err)
        //         return machine.listCache
        //     }

        //     if (cb) cb(machines)
        //     machine.listCache = machines
        //         // console.log(machines)
        //     return machines
        // })
        dockerMachine.ls().then(

            function(output) {
                // console.log('ok')
                loop = 0
                output.forEach(function(el, i, arr) {
                    dockerMachine.inspect(el.name).then(
                        function(inspect) {
                            output[i].inspect = inspect
                            loop += 1
                            if (loop >= arr.length) {
                                // console.log(JSON.stringify(output, null, 2))
                                if (cb) cb(output)
                                machine.listCache = output
                                return output
                            }
                        }
                    ).fail(function(err) {
                        loop += 1
                        console.log(err);
                    })
                })

            }
        ).fail(function(err) {
            console.log(err)
        })





    },
    rm(name, cb) {
        console.log("removing Node:", name)

        return machine.cmd('rm --force '+ name, cb);
    },
    listCache: [

    ]

}

machine.list()
setInterval(function() {
    machine.list()
}, 30000)


module.exports = machine

file_2.js

const docker = require('dockerode')
const machine = require('./machine')
const spawn = require('child_process').spawn
const execSync = require('child_process').execSync
const _ = require('lodash')
const vm = require('./vm')
var fs = require('fs')

var PROJECT = 'boinc-156511'
var REGION = 'us-central1'
var ZONE = 'us-central1-a'

var managerName = "devswarm-1"


swarm = {
    initParams: {
        name: 'defaultSwarm',
        size: 5
    },
    create(params) {
        params.name = String(params.name).toLowerCase()
        swarm.initParams = params
        done = 0
        swarmSize = params.size
        swarmName = params.name
        managerName = swarmName + '-1'

        for (var i = 1; i <= swarmSize; i++) {
            vmParam = _.cloneDeep(params)
            vmParam.nodeName = vmParam.name + '-' + i
            vm.init(vmParam, finished)
        }

        function finished(param) {
            done += 1
                // console.log(done, swarmSize)
            console.log('finished:', param.name, done)

            if (done >= swarmSize) {
                console.log("all VMs are ready, need to setup Manager")
                    // swarm.setupManager(managerName)
            }
        }
    },
    setupManager(managerName) {
        //this is just for convenience
        reserveIP(managerName, swarm.initManager)
    },
    initManager(managerIP) {
        swarm.initParams.managerIP = managerIP
        console.log('ready to setup manager on swarm node', managerName)
        
        machine.docker.swarm(managerName, 'init --advertise-addr ' + managerIP, function (result) {
            console.log('initManagerResult:', result)
            machine.docker.swarm(managerName, 'join-token worker -q ', function (initToken) {
                console.log('initToken:', initToken)
                swarm.initWorkers(initToken)
            })
        })
    },
    initWorkers(initToken) {
        done = 0
            //send token info to workers so they can connect
        for (var i = 2; i <= swarm.initParams.size; i++) {
            workerName = swarm.initParams.name + '-' + i
            swarm.join(workerName, managerIP, initToken, finished)
        }

        function finished(workerName) {
            done += 1
            console.log('WorkersJoined:', done)
            if (done >= swarm.initParams.size) {
                console.log('all workers have been joined to the swarm')
            }
        }
    },
    join(workerName, managerIP, workerToken, cb) {
        machine.docker.swarm(workerName, 'join --token ' + workerToken + ' ' + managerIP + ':2377', function (result) {
            console.log('joined Worker:', workerName, result)
            if (cb) cb(workerName)
        })
    },
    remove(managerName, workerName, cb) {
        machine.docker.node(managerName, 'rm --force ' + workerName, function(result) {
            console.log('removed Worker from Swarm:', workerName, result)
            if (cb) cb(workerName)
        })
    },
    addWorkers(params) {
        done = 0
        lastNode = parseInt((params.startIndex - 1) + params.size)

        function finished(param) {
            done += 1
            console.log('finished:', param.name, done)
            swarm.join(param.name, params.managerIP, params.token)
        }

        params.token = machine.docker.swarm(params.managerName, 'join-token worker -q ', function (token) {
            params.token = token;
            machine.ip(params.managerName, function (managerIP) {
                params.managerIP = managerIP;

                for (var i = params.startIndex; i <= lastNode; i++) {
                    vmParam = _.cloneDeep(params)
                    vmParam.name = vmParam.name + '-' + i
                    vm.init(vmParam, finished)
                }
            })
        })
    },
    removeWorkers(params) {
        done = 0
        lastNode = parseInt((params.startIndex - 1) + params.size)

        for (var i = params.startIndex; i <= lastNode; i++) {
            vmParam = _.cloneDeep(params)
            vmParam.name = vmParam.name + '-' + i
            swarm.remove(params.managerName, vmParam.name, finished)
        }

        function finished(vmName) {
            done += 1
            console.log('removed from Swarm:', vmName, done)
            machine.rm(vmName, function (result) {
                console.log('removed Machine:', vmName, result)
            })
        }

    },
    repair(swarmArray) {
        managerName = swarmArray.name + '-1'
        machine.cmd('status ' + managerName, function (status){

            if (status != 'Running') {
                console.log('swarmManger is not running:', managerName)
                return
            }

             machine.docker.node(managerName, 'ls', function (swarmList) {

                if (swarmList.search("This node is not a swarm manager") > -1) {
                    machine.ip(managerName, function (managerIP) {
                        machine.docker.swarm(managerName, 'init --advertise-addr ' + managerIP)
                    })

                } else {
                    machine.docker.node(managerName, `ls | grep 'Ready'`, function (nodeCount) {
                        nodeCount = JSON.stringify(nodeCount).split('\\').length
                    
                        if (nodeCount >= swarmArray.machines.length) {
                            console.log(swarmArray.name + ' is a valid swarm with ' + nodeCount + ' Nodes')
                        } else {
                            machine.ip(managerName, function (managerIP) {
                                machine.docker.swarm(managerName, 'join-token worker -q ', function (initToken) {
                                    swarmArray.machines.forEach(function(el, i, arr) {
                                        if (el.name != managerName)
                                            machine.docker.swarm(el.name, 'leave')
                                        swarm.join(el.name, managerIP, initToken)
                                    })
                                })
                            })
                        }
                    });
                }
             
                swarmArray.machines.forEach(function(el, i, arr) {

                })
            })
        })
    }
}

function reserveIP(managerName, cb) {
    machine.ip(managerName, function (managerIP) {
        
        console.log('ManagerIP:', managerIP)

        try {
            result = execSync(`
                            gcloud compute addresses create $ { ManagerName + -ip }--project $ { PROJECT }--region $ { REGION }--addresses $ { managerIP }
                            `)
            console.log(result)
        } catch (error) {
            console.log('addresses create error:')
        }
        //make sure the port is open for swarm discovery
        try {
            result = execSync(`
                            gcloud compute firewall - rules create swarm - discovery--project $ { PROJECT }--allow = tcp: 2377, udp: 2377 `)
            console.log(result)
        } catch (error) {
            console.log('firewall-rules error:')
        }

        //ready to init swarm manager
        if (cb) cb(managerIP)
    })
}

create = require('../create.json')

// console.log(create)

// swarm.create({
//     size: 4,
//     startIndex: 0,
//     name: "testswarm",
//     google: {
//         machine: {
//             type: 'n1-highcpu-4'
//         }
//     }
// })

// swarm.addWorkers({
//     size: 8,
//     startIndex: 6,
//     name: "bigbertha",
//     managerName: "bigbertha-1",
//     google: {
//         preemptible: true,
//         machine: {
//             type: 'n1-highcpu-4'
//         }
//     }
// })

// swarm.removeWorkers({
//     size: 8,
//     startIndex: 6,
//     name: "bigbertha",
//     managerName: "bigbertha-1",
//     google: {
//         preemptible: true,
//         machine: {
//             type: 'n1-highcpu-4'
//         }
//     }
// })

// swarm.initParams = {
//     size: 3,
//     name: "devswarm"
// }
// managerName = 'devswarm-1'

// swarm.setupManager()

// vm.init({ name: "wut2-test" })


// vm.init({})

module.exports = swarm