@masonite/slab-cli/lib/docker.js

const chalk = require( 'chalk' );
const sh = require( 'shelljs' );
const util = require( './util' );
const config = require( './config' );

const docker = {

	/**
	 * Check if docker is available.
	 * @return {Boolean}
	 */
	isAvailable() {
		const isNotReachable = sh.exec( '(docker ps -q || printf true)', { silent: true });

		if ( isNotReachable.stdout === 'true' ) {
			return false;
		}

		return true;
	},

	/**
	 * Exit program if docker daemon is not running.
	 * @return {String}
	 */
	check() {
		if ( !this.isAvailable() ) {
			console.log( chalk`{red It doesn't look like you have Docker running.}` );
			process.exit( 1 );
		}
	},

	/**
	 * Build the string to be used as the docker run shell command.
	 * https: //docs.docker.com/engine/reference/commandline/run/
	 * @param {String} slug The project's slug.
	 * @param {String} url The project's url.
	 * @param {Object} container
	 * @return {String}
	 */
	buildRunCmd( slug, url, container ) {
		const errors = [];

		const cmdParts = [
			'docker run',
			'-d',
		];

		// Add hostname reference.
		if ( this.checkForOption( container.database ) ) {
			// Database hostname.
		} else {
			// Web server hostname.
			const hostname = util.getProjectHostname( url );
			cmdParts.push( `-h ${hostname}` );
		}

		// Assign a name to the container.
		if ( this.checkForOption( container.database ) ) {
			cmdParts.push( `--name ${slug}_db` );
		} else {
			cmdParts.push( `--name ${slug}` );
		}

		// Set environment variables.
		if ( this.checkForOption( container.env_variables ) ) {
			cmdParts.push( `-e ${container.env_variables.join( ' -e ' )}` );
		}

		// Bind mount a volume.
		if ( this.checkForOption( container.volumes ) ) {
			cmdParts.push( `-v ${container.volumes.join( ' -v ' )}` );
		}

		// Expose a port or a range of ports.
		if ( this.checkForOption( container.expose ) ) {
			cmdParts.push( `-p ${container.expose}` );
		}

		// Add link to another container.
		if ( !this.checkForOption( container.database ) && this.checkForOption( container.link ) ) {
			cmdParts.push( `--link ${container.link}` );
		}

		// Container name.
		if ( this.checkForOption( container.image ) ) {
			cmdParts.push( container.image );
		} else {
			errors.push( chalk`Cannot find docker image.` );
		}

		// Report any errors.
		if ( errors.length ) {
			errors.forEach( ( error ) => {
				console.log( chalk`{red Error:} ${error}` );
			});
			process.exit( 1 );
		}

		const cmd = cmdParts.join( ' ' );

		return cmd;
	},

	/**
	 * Build the string to be ran from inside the docker container after creation.
	 * @param {String} slug The project's slug.
	 * @param {Object} container
	 * @return {String}
	 */
	buildContainerCmd( slug, container ) {
		const cmd = `docker exec ${slug} bash -c '${container.after_run_container_cmd}'`;

		return cmd;
	},

	/**
	 * Check if option exists.
	 * @param {String|Object} option
	 * @return {Boolean}
	 */
	checkForOption( option ) {
		let optionExists = true;

		if ( typeof option === 'object' && util.isEmptyObject( option ) ) {
			optionExists = false;
		}

		if ( option === undefined || typeof option === 'undefined' ) {
			optionExists = false;
		}

		return optionExists;
	},

	/**
	 * Setup selected project type.
	 * @param {String} slug The project's slug.
	 * @param {String} url The project's url.
	 * @param {Object} typeInfo The project's type info.
	 */
	setup( slug, url, typeInfo ) {
		const { containers } = typeInfo;
		const containerNames = [];

		containers.forEach( ( container ) => {
			// Get the latest container image.
			if ( this.checkForOption( container.image ) ) {
				sh.exec( `docker pull ${container.image}` );
			} else {
				console.log( chalk`{red Error: Docker image is not defined.` );
				process.exit( 1 );
			}

			const runCmd = this.buildRunCmd( slug, url, container );

			let containerName;

			if ( this.checkForOption( container.database ) ) {
				containerName = `${slug}_db`;
			} else {
				containerName = `${slug}`;
			}

			let containerCmd = null;

			if ( this.checkForOption( container.after_run_container_cmd ) ) {
				containerCmd = this.buildContainerCmd( slug, container );
			}

			// Primary command for project type's docker container.
			console.log( chalk`{blue ${runCmd}}` );
			sh.exec( runCmd );

			// Secondary command for project type's docker container if needed..
			if ( containerCmd !== null ) {
				console.log( chalk`{blue ${containerCmd}}` );
				sh.exec( containerCmd );
			}

			// Restart docker if needed.
			if ( container.restart ) {
				sh.exec( `docker restart ${containerName}` );
			}

			containerNames.push( containerName );
		});

		config.updateContainerNames( slug, containerNames );
	},

};

module.exports = docker;