Multiple dockerfiles

commands/index.js

@@ -2,7 +2,6 @@ module.exports = function index(pkg) {
   return {
     topic: pkg.topic,
     description: pkg.description,
-    help: pkg.description,
     run: showVersion
   };
 

commands/login.js

@@ -1,49 +1,48 @@
-'use strict';
+const cli = require('heroku-cli-util')
+const child = require('child_process')
+const log = require('../lib/log')
 
-const cli = require('heroku-cli-util');
-const co = require('co');
-const child = require('child_process');
-
-module.exports = function(topic) {
+module.exports = function (topic) {
   return {
     topic: topic,
     command: 'login',
-    flags: [{ name: 'verbose', char: 'v', hasValue: false }],
-    description: 'Logs in to the Heroku Docker registry',
+    flags: [{name: 'verbose', char: 'v', hasValue: false}],
+    description: 'logs in to the Heroku Container Registry',
+    help: `Usage:
+        heroku container:login`,
     needsApp: false,
     needsAuth: true,
-    run: cli.command(co.wrap(login))
-  };
-};
+    run: cli.command(login)
+  }
+}
 
-function* login(context, heroku) {
-  let herokuHost = process.env.HEROKU_HOST || 'heroku.com';
-  let registry = `registry.${ herokuHost }`;
-  let password = context.auth.password;
+async function login (context, heroku) {
+  let herokuHost = process.env.HEROKU_HOST || 'heroku.com'
+  let registry = `registry.${ herokuHost }`
+  let password = context.auth.password
 
   try {
-    let user = yield dockerLogin(registry, password, context.flags.verbose);
+    let user = await dockerLogin(registry, password, context.flags.verbose)
   }
   catch (err) {
-    cli.error(`Error: docker login exited with ${ err }`);
+    cli.error(`Error: docker login exited with ${ err }`)
+    cli.hush(err.stack || err)
   }
 }
 
-function dockerLogin(registry, password, verbose) {
+function dockerLogin (registry, password, verbose) {
   return new Promise((resolve, reject) => {
     let args = [
       'login',
       '--username=_',
       `--password=${ password }`,
       registry
-    ];
-    if (verbose) {
-      console.log(['> docker'].concat(args).join(' '));
-    }
-    child.spawn('docker', args, { stdio: 'inherit' })
+    ]
+    log(verbose, args)
+    child.spawn('docker', args, {stdio: 'inherit'})
       .on('exit', (code, signal) => {
-        if (signal || code) reject(signal || code);
-        else resolve();
-      });
-  });
+        if (signal || code) reject(signal || code)
+        else resolve()
+      })
+  })
 }

commands/logout.js

@@ -1,27 +1,27 @@
-'use strict';
-
 const cli = require('heroku-cli-util');
-const co = require('co');
 const child = require('child_process');
+const log = require('../lib/log');
 
 module.exports = function(topic) {
   return {
     topic: topic,
     command: 'logout',
     flags: [{ name: 'verbose', char: 'v', hasValue: false }],
-    description: 'Logs out from the Heroku Docker registry',
+    description: 'logs out from the Heroku Container Registry',
+    help: `Usage:
+       heroku container:logout`,
     needsApp: false,
     needsAuth: false,
-    run: cli.command(co.wrap(logout))
+    run: cli.command(logout)
   };
 };
 
-function* logout(context, heroku) {
+async function logout(context, heroku) {
   let herokuHost = process.env.HEROKU_HOST || 'heroku.com';
   let registry = `registry.${ herokuHost }`;
 
   try {
-    let user = yield dockerLogout(registry, context.flags.verbose);
+    let user = await dockerLogout(registry, context.flags.verbose);
   }
   catch (err) {
     cli.error(`Error: docker logout exited with ${ err }`);
@@ -34,9 +34,7 @@ function dockerLogout(registry, verbose) {
       'logout',
       registry
     ];
-    if (verbose) {
-      console.log(['> docker'].concat(args).join(' '));
-    }
+    log(verbose, args);
     child.spawn('docker', args, { stdio: 'inherit' })
       .on('exit', (code, signal) => {
         if (signal || code) reject(signal || code);

commands/push.js

@@ -1,77 +1,82 @@
-'use strict';
+const cli = require('heroku-cli-util')
+const Sanbashi = require('../lib/sanbashi')
 
-const cli = require('heroku-cli-util');
-const co = require('co');
-const child = require('child_process');
+let usage = `
+  ${cli.color.bold.underline.magenta('Usage:')}
+  ${ cli.color.white('heroku container:push web')}         	           # Pushes Dockerfile in current directory to web process type
+  ${ cli.color.white('heroku container:push web worker --recursive')}     # Pushes Dockerfile.web and Dockerfile.worker found in current & subdirectories
+  ${ cli.color.white('heroku container:push --recursive')}                # Pushes Dockerfile.* found in current & subdirectories`
 
-module.exports = function(topic) {
+module.exports = function (topic) {
   return {
     topic: topic,
     command: 'push',
-    description: 'Builds, then pushes a Docker image to deploy your Heroku app',
+    description: 'builds, then pushes Docker images to deploy your Heroku app',
     needsApp: true,
     needsAuth: true,
-    args: [{ name: 'process', optional: true }],
-    flags: [{ name: 'verbose', char: 'v', hasValue: false }],
-    run: cli.command(co.wrap(push))
-  };
-};
+    variableArgs: true,
+    help: usage,
+    flags: [
+      {
+        name: 'verbose',
+        char: 'v',
+        hasValue: false
+      },
+      {
+        name: 'recursive',
+        char: 'R',
+        hasValue: false
+      }
+    ],
+    run: cli.command(push)
+  }
+}
 
-function* push(context, heroku) {
-  let herokuHost = process.env.HEROKU_HOST || 'heroku.com';
-  let registry = `registry.${ herokuHost }`;
-  let proc = context.args.process || 'web';
-  let resource = `${ registry }/${ context.app }/${ proc }`;
+let push = async function (context, heroku) {
+  const recurse = !!context.flags.recursive
+  if (context.args.length === 0 && !recurse) {
+    cli.error(`Error: Requires either --recursive or one or more process types\n ${usage} `)
+    process.exit(1)
+  }
+  if(context.args.length > 1 && !recurse){
+    cli.error(`Error: Please specify one target process type\n ${usage} `)
+    process.exit(1)
+  }
+  let herokuHost = process.env.HEROKU_HOST || 'heroku.com'
+  let registry = `registry.${ herokuHost }`
+  let dockerfiles = Sanbashi.getDockerfiles(process.cwd(), recurse)
+  let processTypes = ['standard']
+  if(recurse){
+    processTypes = context.args
+  }
+  let possibleJobs = Sanbashi.getJobs(`${ registry }/${ context.app }`, processTypes, dockerfiles)
+  let jobs = await Sanbashi.chooseJobs(possibleJobs)
+  if (!jobs.length) {
+    cli.warn('No images to push')
+    process.exit(1)
+  }
 
   try {
-    let build = yield buildImage(resource, context.cwd, context.flags.verbose);
+    for (let job of jobs) {
+      cli.styledHeader(`Building ${job.name} (${job.dockerfile})`)
+      await Sanbashi.buildImage(job.dockerfile, job.resource, context.flags.verbose)
+    }
   }
   catch (err) {
-    cli.error(`Error: docker build exited with ${ err }`);
-    process.exit(1);
+    cli.error(`Error: docker build exited with ${ err }`)
+    cli.hush(err.stack || err)
+    process.exit(1)
   }
 
   try {
-    let push = yield pushImage(resource, context.flags.verbose);
+    for (let job of jobs) {
+     cli.styledHeader(`Pushing  ${job.name}  (${job.dockerfile })`)
+      await Sanbashi.pushImage(job.resource, context.flags.verbose)
+    }
   }
   catch (err) {
-    cli.error(`Error: docker push exited with ${ err }`);
-    process.exit(1);
+    cli.error(`Error: docker push exited with ${ err }`)
+    cli.hush(err.stack || err)
+    process.exit(1)
   }
 }
-
-function buildImage(resource, cwd, verbose) {
-  return new Promise((resolve, reject) => {
-    let args = [
-      'build',
-      '-t',
-      resource,
-      cwd
-    ];
-    if (verbose) {
-      console.log(['> docker'].concat(args).join(' '));
-    }
-    child.spawn('docker', args, { stdio: 'inherit' })
-      .on('exit', (code, signal) => {
-        if (signal || code) reject(signal || code);
-        else resolve();
-      });
-  });
-}
-
-function pushImage(resource, verbose) {
-  return new Promise((resolve, reject) => {
-    let args = [
-      'push',
-      resource
-    ];
-    if (verbose) {
-      console.log(['> docker'].concat(args).join(' '));
-    }
-    child.spawn('docker', args, { stdio: 'inherit' })
-      .on('exit', (code, signal) => {
-        if (signal || code) reject(signal || code);
-        else resolve();
-      });
-  });
-}

index.js

@@ -1,6 +1,10 @@
 var pkg = require('./package.json');
 
 module.exports = {
+	topic: { 
+		description: 'Use containers to build and deploy Heroku apps', 
+   	name: 'container'
+	},
   commands: [
     require('./commands/index')(pkg),
     require('./commands/login')(pkg.topic),

lib/log.js

@@ -0,0 +1,4 @@
+module.exports = (visible, args) => {
+  if (!visible) return;
+  console.log(`> docker ${ args.join(' ') }`);
+};

lib/sanbashi.js

@@ -0,0 +1,105 @@
+// 'sanbashi' is a word in Japanese that refers to a pier or dock, usually very large in size, such as found in Tokyo's O-daiba region
+
+let Glob = require('glob')
+let Path = require('path')
+let Inquirer = require('inquirer')
+const Child = require('child_process')
+const log = require('./log')
+
+const DOCKERFILE_REGEX = /\bDockerfile(.\w*)?$/
+let Sanbashi = function () {}
+
+Sanbashi.getDockerfiles = function (rootdir, recursive) {
+  let match = recursive ? './**/Dockerfile?(.)*' : 'Dockerfile*'
+  let dockerfiles = Glob.sync(match, {
+    cwd: rootdir,
+    nonull: false,
+    nodir: true
+  })
+  if (recursive) {
+    dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile\.[\w]+/))
+  }
+  return dockerfiles.map(file => Path.join(rootdir, file))
+}
+
+Sanbashi.getJobs = function (resourceRoot, procs, dockerfiles) {
+  return dockerfiles
+  // convert all Dockerfiles into job Objects
+    .map((dockerfile) => {
+      let match = dockerfile.match(DOCKERFILE_REGEX)
+      if (!match) return
+      let proc = (match[1] || '.standard').slice(1)
+      return {
+        name: proc,
+        resource: `${ resourceRoot }/${ proc }`,
+        dockerfile: dockerfile,
+        postfix: Path.basename(dockerfile) === 'Dockerfile' ? 0 : 1,
+        depth: Path.normalize(dockerfile).split(Path.sep).length
+      }
+    })
+    // if process types have been specified, filter non matches out
+    .filter(job => {
+      return job && (!procs.length || procs.indexOf(job.name) !== -1)
+    })
+    // prefer closer Dockerfiles, then prefer Dockerfile over Dockerfile.web
+    .sort((a, b) => {
+      return a.depth - b.depth || a.postfix - b.postfix
+    })
+    // group all Dockerfiles for the same process type together
+    .reduce((jobs, job) => {
+      jobs[job.name] = jobs[job.name] || []
+      jobs[job.name].push(job)
+      return jobs
+    }, {})
+}
+
+Sanbashi.chooseJobs = async function (jobs) {
+  let chosenJobs = []
+  for (let processType in jobs) {
+    let group = jobs[processType]
+    if (group.length > 1) {
+      let prompt = {
+        type: 'list',
+        name: processType,
+        choices: group.map(j => j.dockerfile),
+        message: `Found multiple Dockerfiles with process type ${processType}. Please choose one to build and push `
+      }
+      let answer = await Inquirer.prompt(prompt)
+      chosenJobs.push(group.find(o => o.dockerfile === answer[processType]))
+    } else {
+      chosenJobs.push(group[0])
+    }
+  }
+  return chosenJobs
+}
+
+Sanbashi.buildImage = function (dockerfile, resource, verbose) {
+  return new Promise((resolve, reject) => {
+    let cwd = Path.dirname(dockerfile)
+    let args = ['build', '-f', dockerfile, '-t', resource, cwd]
+    log(verbose, args)
+    Child.spawn('docker', args, {
+      stdio: 'inherit'
+    })
+      .on('exit', (code, signal) => {
+        if (signal || code) reject(signal || code)
+        else resolve()
+      })
+  })
+}
+
+Sanbashi.pushImage = function (resource, verbose) {
+  return new Promise((resolve, reject) => {
+    let args = ['push', resource]
+    log(verbose, args)
+    Child.spawn('docker', args, {
+      stdio: 'inherit'
+    })
+      .on('exit', (code, signal) => {
+        if (signal || code) reject(signal || code)
+        else resolve()
+      })
+  })
+}
+
+module.exports = Sanbashi