now running async and a lot faster

ts/npmdocker.cli.ts

@@ -7,17 +7,10 @@ import * as DockerModule from './npmdocker.docker'
 
 let npmdockerCli = new plugins.smartcli.Smartcli()
 
-plugins.beautylog.ora.start()
 export let run = () => {
-  npmdockerCli.standardTask().then(argvArg => {
-    let done = plugins.q.defer()
-    ConfigModule.run()
+  npmdockerCli.standardTask().then(async (argvArg) => {
+    let configArg = await ConfigModule.run()
       .then(DockerModule.run)
-      .then((configArg) => {
-        done.resolve(configArg)
-      })
-    return done.promise
-  }).then((configArg: ConfigModule.IConfig) => {
     if (configArg.exitCode === 0) {
       plugins.beautylog.success('container ended all right!')
     } else {
@@ -26,31 +19,31 @@ export let run = () => {
     }
   })
 
-  npmdockerCli.addCommand('clean').then(argvArg => {
+  npmdockerCli.addCommand('clean').then(async (argvArg) => {
+    plugins.beautylog.ora.start()
     plugins.beautylog.ora.text('cleaning up docker env...')
     if (argvArg.all) {
       plugins.beautylog.ora.text('killing any running docker containers...')
-      plugins.shelljs.exec(`docker kill $(docker ps -q)`)
+      await plugins.smartshell.exec(`docker kill $(docker ps -q)`)
 
       plugins.beautylog.ora.text('removing stopped containers...')
-      plugins.shelljs.exec(`docker rm $(docker ps -a -q)`)
+      await plugins.smartshell.exec(`docker rm $(docker ps -a -q)`)
 
       plugins.beautylog.ora.text('removing images...')
-      plugins.shelljs.exec(`docker rmi $(docker images -q -f dangling=true)`)
+      await plugins.smartshell.exec(`docker rmi $(docker images -q -f dangling=true)`)
 
       plugins.beautylog.ora.text('removing all other images...')
-      plugins.shelljs.exec(`docker rmi $(docker images -a -q)`)
+      await plugins.smartshell.exec(`docker rmi $(docker images -a -q)`)
 
       plugins.beautylog.ora.text('removing all volumes...')
-      plugins.shelljs.exec(`docker volume rm $(docker volume ls -f dangling=true -q)`)
+      await plugins.smartshell.exec(`docker volume rm $(docker volume ls -f dangling=true -q)`)
     }
     plugins.beautylog.ora.endOk('docker environment now is clean!')
   })
 
-  npmdockerCli.addCommand('speedtest').then(argvArg => {
-    plugins.beautylog.ora.text('cleaning up docker env...')
-    plugins.shelljs.exec(`docker pull tianon/speedtest && docker run --rm tianon/speedtest`)
-    plugins.beautylog.ora.endOk('docker environment now is clean!')
+  npmdockerCli.addCommand('speedtest').then(async (argvArg) => {
+    plugins.beautylog.ok('Starting speedtest')
+    await plugins.smartshell.exec(`docker pull tianon/speedtest && docker run --rm tianon/speedtest`)
   })
 
   npmdockerCli.startParse()

ts/npmdocker.config.ts

@@ -12,20 +12,17 @@ export interface IConfig {
   keyValueObjectArray: IKeyValueObject[]
 };
 
-let getQenvKeyValueObject = () => {
-  let done = plugins.q.defer()
+let getQenvKeyValueObject = async () => {
   let qenvKeyValueObjectArray: IKeyValueObject[]
   if (plugins.smartfile.fs.fileExistsSync(plugins.path.join(paths.cwd, 'qenv.yml'))) {
     qenvKeyValueObjectArray = new plugins.qenv.Qenv(paths.cwd, '.nogit/').keyValueObjectArray
   } else {
     qenvKeyValueObjectArray = []
   };
-  done.resolve(qenvKeyValueObjectArray)
-  return done.promise
+  return qenvKeyValueObjectArray
 }
 
-let buildConfig = (qenvKeyValueObjectArrayArg: IKeyValueObject) => {
-  let done = plugins.q.defer()
+let buildConfig = async (qenvKeyValueObjectArrayArg: IKeyValueObject[]) => {
   let npmextra = new plugins.npmextra.Npmextra(paths.cwd)
   let config = npmextra.dataFor<IConfig>(
     'npmdocker',
@@ -36,14 +33,10 @@ let buildConfig = (qenvKeyValueObjectArrayArg: IKeyValueObject) => {
       keyValueObjectArray: qenvKeyValueObjectArrayArg
     }
   )
-  done.resolve(config)
-  return done.promise
+  return config
 }
 
-export let run = () => {
-  let done = plugins.q.defer()
-  getQenvKeyValueObject()
-    .then(buildConfig)
-    .then(done.resolve)
-  return done.promise
-}
+export let run = async (): Promise<IConfig> => {
+  let config = await getQenvKeyValueObject().then(buildConfig)
+  return config
+}

ts/npmdocker.docker.ts

@@ -24,7 +24,7 @@ let dockerData = {
 let checkDocker = () => {
   let done = plugins.q.defer()
   plugins.beautylog.ora.text('checking docker...')
-  if (plugins.shelljs.which('docker')) {
+  if (plugins.smartshell.which('docker')) {
     plugins.beautylog.ok('Docker found!')
     done.resolve()
   } else {
@@ -54,145 +54,104 @@ let buildDockerFile = () => {
 /**
  * builds the Dockerimage from the built Dockerfile
  */
-let buildDockerImage = () => {
-  let done = plugins.q.defer()
+let buildDockerImage = async () => {
   plugins.beautylog.ora.text('pulling latest base image from registry...')
-  plugins.shelljs.exec(
-    `docker pull ${config.baseImage}`,
-    {
-      silent: true
-    },
-    () => {
-      plugins.beautylog.ora.text('building Dockerimage...')
-      // are we creating a build context form project ?
-      if (process.env.CI === 'true') {
-        plugins.beautylog.ora.text('creating build context...')
-        plugins.smartfile.fs.copySync(paths.cwd, paths.buildContextDir)
-      }
-      plugins.shelljs.exec(
-        `docker build -f ${paths.dockerfile} -t ${dockerData.imageTag} ${paths.assets}`,
-        {
-          silent: true
-        },
-        () => {
-          plugins.beautylog.ok('Dockerimage built!')
-          done.resolve()
-        }
-      )
+  await plugins.smartshell.execSilent(
+    `docker pull ${config.baseImage}`
+  ).then(async () => {
+    plugins.beautylog.ora.text('building Dockerimage...')
+    // are we creating a build context form project ?
+    if (process.env.CI === 'true') {
+      plugins.beautylog.ora.text('creating build context...')
+      plugins.smartfile.fs.copySync(paths.cwd, paths.buildContextDir)
     }
-  ) // first pull latest version of baseImage
-  return done.promise
+    await plugins.smartshell.execSilent(
+      `docker build -f ${paths.dockerfile} -t ${dockerData.imageTag} ${paths.assets}`
+    ).then(async () => {
+      plugins.beautylog.ok('Dockerimage built!')
+    })
+  })
 }
 
-let buildDockerProjectMountString = () => {
-  let done = plugins.q.defer()
+let buildDockerProjectMountString = async () => {
   if (process.env.CI !== 'true') {
     dockerData.dockerProjectMountString = `-v ${paths.cwd}:/workspace`
   };
-  done.resolve()
-  return done.promise
 }
 
 /**
  * builds an environment string that docker cli understands
  */
-let buildDockerEnvString = () => {
-  let done = plugins.q.defer()
+let buildDockerEnvString = async () => {
   for (let keyValueObjectArg of config.keyValueObjectArray) {
     let envString = dockerData.dockerEnvString = dockerData.dockerEnvString + `-e ${keyValueObjectArg.key}=${keyValueObjectArg.value} `
   };
-  done.resolve()
-  return done.promise
 }
 
 /**
  * creates string to mount the docker.sock inside the testcontainer
  */
-let buildDockerSockString = () => {
-  let done = plugins.q.defer()
+let buildDockerSockString = async () => {
   if (config.dockerSock) {
     dockerData.dockerSockString = `-v /var/run/docker.sock:/var/run/docker.sock`
   };
-  done.resolve()
-  return done
 }
 
 /**
  * creates a container by running the built Dockerimage
  */
-let runDockerImage = () => {
+let runDockerImage = async () => {
   let done = plugins.q.defer()
   plugins.beautylog.ora.text('starting Container...')
   plugins.beautylog.ora.end()
   plugins.beautylog.log('now running Dockerimage')
-  config.exitCode = plugins.shelljs.exec(`docker run ${dockerData.dockerProjectMountString} ${dockerData.dockerSockString} ${dockerData.dockerEnvString} --name ${dockerData.containerName} ${dockerData.imageTag}`).code
-  done.resolve()
-  return done.promise
+  config.exitCode = (await plugins.smartshell.exec(`docker run ${dockerData.dockerProjectMountString} ${dockerData.dockerSockString} ${dockerData.dockerEnvString} --name ${dockerData.containerName} ${dockerData.imageTag}`)).exitCode
 }
 
 /**
  * cleans up: deletes the test container
  */
-let deleteDockerContainer = () => {
-  let done = plugins.q.defer()
-  plugins.shelljs.exec(`docker rm -f ${dockerData.containerName}`, {
-    silent: true
-  })
-  done.resolve()
-  return done.promise
+let deleteDockerContainer = async () => {
+  await plugins.smartshell.execSilent(`docker rm -f ${dockerData.containerName}`)
 }
 
 /**
  * cleans up deletes the test image
  */
-let deleteDockerImage = () => {
-  let done = plugins.q.defer()
-  plugins.shelljs.exec(`docker rmi ${dockerData.imageTag}`, {
-    silent: true
-  })
-  done.resolve()
-  return done.promise
+let deleteDockerImage = async () => {
+  await plugins.smartshell.exec(`docker rmi ${dockerData.imageTag}`)
 }
 
 /**
  * cleans up, deletes the build context
  */
-let deleteBuildContext = () => {
-  let done = plugins.q.defer()
-  plugins.smartfile.fs.remove(paths.buildContextDir)
-    .then(() => {
-      done.resolve()
-    })
-  return done.promise
+let deleteBuildContext = async () => {
+  await plugins.smartfile.fs.remove(paths.buildContextDir)
 }
 
-let preClean = () => {
-  let done = plugins.q.defer()
-  deleteDockerImage()
+let preClean = async () => {
+  await deleteDockerImage()
     .then(deleteDockerContainer)
-    .then(() => {
+    .then(async () => {
       plugins.beautylog.ok('ensured clean Docker environment!')
-      done.resolve()
     })
 }
 
-let postClean = () => {
-  let done = plugins.q.defer()
-  deleteDockerContainer()
+let postClean = async () => {
+  await deleteDockerContainer()
     .then(deleteDockerImage)
     .then(deleteBuildContext)
-    .then(() => {
+    .then(async () => {
       plugins.beautylog.ok('cleaned up!')
-      done.resolve()
     })
 }
 
 
 
-export let run = (configArg) => {
-  let done = plugins.q.defer()
+export let run = async (configArg: IConfig): Promise<IConfig> => {
+  plugins.beautylog.ora.start()
   config = configArg
-  checkDocker()
+  let resultConfig = await checkDocker()
     .then(preClean)
     .then(buildDockerFile)
     .then(buildDockerImage)
@@ -201,8 +160,6 @@ export let run = (configArg) => {
     .then(buildDockerSockString)
     .then(runDockerImage)
     .then(postClean)
-    .then(() => {
-      done.resolve(config);
-    }).catch(err => { console.log(err) })
-  return done.promise
+    .catch(err => { console.log(err) })
+  return config
 }

ts/npmdocker.plugins.ts

@@ -5,9 +5,9 @@ import * as path from 'path'
 import * as projectinfo from 'projectinfo'
 import * as q from 'smartq'
 import * as qenv from 'qenv'
-import * as shelljs from 'shelljs'
 import * as smartcli from 'smartcli'
 import * as smartfile from 'smartfile'
+import * as smartshell from 'smartshell'
 import * as smartstring from 'smartstring'
 
 export {
@@ -17,8 +17,8 @@ export {
   projectinfo,
   q,
   qenv,
-  shelljs,
   smartcli,
   smartfile,
+  smartshell,
   smartstring
 }