firmament-docker
Version:
Typescript classes for performing Docker operations
314 lines • 13.1 kB
JavaScript
;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
const inversify_1 = require("inversify");
const inversify_config_1 = require("../../inversify.config");
const _ = require("lodash");
const make_command_impl_1 = require("./make-command-impl");
let DockerCommandImpl = class DockerCommandImpl {
constructor(commandUtil, spawn, dockerMake, dockerImageManagement, dockerContainerManagement, commandLine) {
this.commandUtil = commandUtil;
this.spawn = spawn;
this.dockerMake = dockerMake;
this.dockerImageManagement = dockerImageManagement;
this.dockerContainerManagement = dockerContainerManagement;
this.commandLine = commandLine;
this.aliases = [];
this.command = '';
this.commandDesc = '';
this.handler = () => {
};
this.options = {};
this.subCommands = [];
this.buildCommandTree();
}
buildCommandTree() {
this.aliases = ['docker', 'd'];
this.command = '<subCommand>';
this.commandDesc = 'Support for working with Docker containers';
this.pushLoadImagesCommand();
this.pushSaveImagesCommand();
this.pushCleanVolumesCommand();
this.pushImagesCommand();
this.pushPsCommand();
this.pushStartCommand();
this.pushStopCommand();
this.pushRemoveContainersCommand();
this.pushRemoveImagesCommand();
this.pushShellCommand();
}
pushSaveImagesCommand() {
const me = this;
const saveImagesCommand = inversify_config_1.default.get('CommandImpl');
saveImagesCommand.aliases = ['save'];
saveImagesCommand.commandDesc = 'Save local docker images to tar file';
saveImagesCommand.options = {
regexp: {
alias: 'r',
type: 'string',
default: '.*',
desc: 'javascript regular expression text to match docker images'
},
outdir: {
alias: 'o',
type: 'string',
default: process.cwd(),
desc: 'directory to write image tar files to'
}
};
saveImagesCommand.handler = (argv) => {
me.dockerImageManagement.saveImages(argv.regexp, argv.outdir, (err) => {
me.commandUtil.processExitWithError(err);
});
};
me.subCommands.push(saveImagesCommand);
}
pushLoadImagesCommand() {
const me = this;
const loadImagesCommand = inversify_config_1.default.get('CommandImpl');
loadImagesCommand.aliases = ['load'];
loadImagesCommand.commandDesc = 'Load docker images locally from tar file';
loadImagesCommand.options = {
regexp: {
alias: 'r',
type: 'string',
default: '.*',
desc: 'javascript regular expression text to match tar files'
},
indir: {
alias: 'i',
type: 'string',
default: process.cwd(),
desc: 'directory containing the docker tar files'
}
};
loadImagesCommand.handler = (argv) => {
me.dockerImageManagement.loadImages(argv.regexp, argv.indir, (err) => {
me.commandUtil.processExitWithError(err);
});
};
me.subCommands.push(loadImagesCommand);
}
pushCleanVolumesCommand() {
const me = this;
const cleanVolumesCommand = inversify_config_1.default.get('CommandImpl');
cleanVolumesCommand.aliases = ['clean-volumes', 'cv'];
cleanVolumesCommand.commandDesc = 'Clean orphaned Docker resources';
cleanVolumesCommand.handler = (argv) => {
const script = require('path').resolve(__dirname, '../../../bash/_docker-cleanup-volumes.sh');
me.spawn.sudoSpawnAsync(['/bin/bash', script], {}, (err) => {
}, (err) => {
me.commandUtil.processExitWithError(err);
});
};
me.subCommands.push(cleanVolumesCommand);
}
pushRemoveImagesCommand() {
const me = this;
const removeCommand = inversify_config_1.default.get('CommandImpl');
removeCommand.aliases = ['rmi'];
removeCommand.commandDesc = 'Remove Docker images';
removeCommand.handler = (argv) => {
me.dockerImageManagement.removeImages(argv._.slice(2), (err) => {
me.commandUtil.processExitWithError(err);
});
};
me.subCommands.push(removeCommand);
}
pushRemoveContainersCommand() {
const me = this;
const removeCommand = inversify_config_1.default.get('CommandImpl');
removeCommand.aliases = ['rm'];
removeCommand.commandDesc = 'Remove Docker containers';
removeCommand.handler = (argv) => {
me.dockerContainerManagement.removeContainers(argv._.slice(2), (err) => {
me.commandUtil.processExitWithError(err);
});
};
me.subCommands.push(removeCommand);
}
pushShellCommand() {
const me = this;
const shellCommand = inversify_config_1.default.get('CommandImpl');
shellCommand.aliases = ['sh'];
shellCommand.commandDesc = 'Run bash shell in Docker container';
shellCommand.handler = (argv) => {
me.bashInToContainer(argv._.slice(2), (err) => {
me.commandUtil.processExitWithError(err);
});
};
this.subCommands.push(shellCommand);
}
pushStartCommand() {
const me = this;
const startCommand = inversify_config_1.default.get('CommandImpl');
startCommand.aliases = ['start'];
startCommand.commandDesc = 'Start Docker containers';
startCommand.options = {
input: {
alias: 'i',
type: 'string',
desc: 'Firmament JSON file describing the containers to start (in correct order)'
}
};
startCommand.handler = me.startOrStopContainers.bind(me);
me.subCommands.push(startCommand);
}
startOrStopContainers(argv) {
const me = this;
let action = 'Stopping';
let start = false;
if (argv._[1] === 'start') {
action = 'Starting';
start = true;
}
let containerNames;
if (argv.input === undefined) {
containerNames = argv._.slice(2);
}
else {
const { fullInputPath, sortedContainerConfigs } = me.dockerMake.getSortedContainerConfigsFromJsonFile(argv.input || make_command_impl_1.MakeCommandImpl.defaultConfigFilename);
me.commandUtil.log(`${action} Docker containers described in: '${fullInputPath}'`);
containerNames = _.map(start ? sortedContainerConfigs : sortedContainerConfigs.reverse(), 'name');
}
me.dockerContainerManagement.startOrStopContainers(containerNames, start, () => me.commandUtil.processExit());
}
pushStopCommand() {
const me = this;
const stopCommand = inversify_config_1.default.get('CommandImpl');
stopCommand.aliases = ['stop'];
stopCommand.commandDesc = 'Stop Docker containers';
stopCommand.options = {
input: {
alias: 'i',
type: 'string',
desc: 'Firmament JSON file describing the containers to start (in correct order)'
}
};
stopCommand.handler = me.startOrStopContainers.bind(me);
me.subCommands.push(stopCommand);
}
pushImagesCommand() {
const me = this;
const imagesCommand = inversify_config_1.default.get('CommandImpl');
imagesCommand.aliases = ['images'];
imagesCommand.commandDesc = 'List Docker images';
imagesCommand.options = {
all: {
alias: 'a',
boolean: true,
default: false,
desc: 'Show intermediate images also'
}
};
imagesCommand.handler = argv => me.printImagesList(argv, () => me.commandUtil.processExit());
this.subCommands.push(imagesCommand);
}
pushPsCommand() {
const me = this;
const psCommand = inversify_config_1.default.get('CommandImpl');
psCommand.aliases = ['ps'];
psCommand.commandDesc = 'List Docker containers';
psCommand.options = {
all: {
alias: 'a',
boolean: true,
default: false,
desc: 'Show non-running containers also'
}
};
psCommand.handler = argv => me.printContainerList(argv, () => me.commandUtil.processExit());
this.subCommands.push(psCommand);
}
printImagesList(argv, cb) {
this.dockerImageManagement.listImages(argv.a, (err, images) => {
this.prettyPrintDockerImagesList(err, images, cb);
});
}
printContainerList(argv, cb) {
this.dockerContainerManagement.listContainers(argv.a, (err, containers) => {
this.prettyPrintDockerContainerList(err, containers, argv.a, cb);
});
}
bashInToContainer(ids, cb) {
if (ids.length !== 1) {
let msg = '\nSpecify container to shell into by FirmamentId, Docker ID or Name.\n';
msg += '\nExample: $ ... d sh 2 <= Open bash shell in container with FirmamentId "2"\n';
cb(new Error(msg));
return;
}
this.dockerContainerManagement.exec(ids[0].toString(), '/bin/bash', cb);
}
prettyPrintDockerImagesList(err, images, cb) {
const me = this;
if (!images || !images.length) {
const msg = me.commandUtil.returnErrorStringOrMessage(err, '\nNo images\n');
console.log(msg);
}
else {
const timeAgo = require('time-ago')();
const fileSize = require('filesize');
me.commandLine.printTable(images.map(image => {
try {
const ID = image.firmamentId;
const repoTags = image.RepoTags[0].split(':');
const Repository = repoTags[0];
const Tag = repoTags[1];
const ImageId = image.Id.substring(7, 19);
const nowTicks = +new Date();
const tickDiff = nowTicks - (1000 * image.Created);
const Created = timeAgo.ago(nowTicks - tickDiff);
const Size = fileSize(image.Size);
return { ID, Repository, Tag, ImageId, Created, Size };
}
catch (err) {
console.log(err.message);
return {};
}
}));
}
cb();
}
prettyPrintDockerContainerList(err, containers, all, cb) {
const me = this;
if (!containers || !containers.length) {
const msg = me.commandUtil.returnErrorStringOrMessage(err, '\nNo ' + (all ? '' : 'Running ') + 'Containers\n');
console.log(msg);
}
else {
me.commandLine.printTable(containers.map(container => {
return {
ID: container.firmamentId,
Name: container.Names[0],
Image: container.Image,
DockerId: container.Id.substring(0, 11),
Status: container.Status
};
}));
}
cb();
}
};
DockerCommandImpl = __decorate([
inversify_1.injectable(),
__param(0, inversify_1.inject('CommandUtil')),
__param(1, inversify_1.inject('Spawn')),
__param(2, inversify_1.inject('DockerMake')),
__param(3, inversify_1.inject('DockerImageManagement')),
__param(4, inversify_1.inject('DockerContainerManagement')),
__param(5, inversify_1.inject('CommandLine')),
__metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object])
], DockerCommandImpl);
exports.DockerCommandImpl = DockerCommandImpl;
//# sourceMappingURL=docker-command-impl.js.map