Implementation
Future<bool> executeConsoleCMD(ConsoleCMD cmd) async {
switch (cmd.cmd) {
case 'help':
{
await showHelp();
return true;
}
case 'initialize':
{
return dockerCommander.initialize();
}
case 'checkdaemon':
{
await dockerCommander.checkDaemon();
return true;
}
case 'close':
{
await dockerCommander.close();
return true;
}
case 'ps':
{
var exec = await dockerCommander.command('ps', ['-a']);
return await _processReturn(cmd, exec);
}
case 'createnetwork':
{
var parameters = await _requireParameters({
'networkName': cmd.get(0, 'networkName', 'network', 'name'),
}, {
'networkName',
}, cmd.askAllProperties);
var networkName = await dockerCommander.createNetwork(
parameters['networkName']!,
);
if (networkName != null) {
await _printToConsole('CREATED NETWORK> $networkName');
return true;
}
return false;
}
case 'createcontainer':
{
var parameters = await _requireParameters({
'containerName': cmd.get(0, 'containerName', 'container'),
'imageName': cmd.get(1, 'imageName', 'image'),
'version': cmd.get(2, 'version', 'ver'),
'ports': cmd.get(3, 'ports', 'port'),
'volumes': cmd.get(4, 'volumes'),
'hostname': cmd.get(5, 'hostname', 'host'),
'network': cmd.get(6, 'network'),
'environment': cmd.get(7, 'environment', 'env'),
'cleanContainer': cmd.getProperty('cleanContainer'),
'health-cmd': cmd.getProperty('health-cmd'),
'health-interval': cmd.getProperty('health-interval'),
'health-retries': cmd.getProperty('health-retries'),
'health-start-period': cmd.getProperty('health-start-period'),
'health-timeout': cmd.getProperty('health-timeout'),
'restart': cmd.getProperty('restart'),
}, {
'containerName',
'imageName',
}, cmd.askAllProperties);
var paramPorts = await _parsePortsProperties(parameters);
var paramVolumes = await _parseVolumesProperties(parameters);
var paramEnvironment = await _parseEnvironmentProperties(parameters);
var containerInfos = await dockerCommander.createContainer(
parameters['containerName']!,
parameters['imageName']!,
version: parameters['version'],
ports: paramPorts,
volumes: paramVolumes,
hostname: parameters['hostname'],
network: parameters['network'],
environment: paramEnvironment,
cleanContainer: parseBool(parameters['cleanContainer']) ?? false,
healthCmd: parameters['health-cmd'],
healthInterval: _parseDurationInMs(parameters['health-interval']),
healthRetries: parseInt(parameters['health-retries']),
healthStartPeriod:
_parseDurationInMs(parameters['health-start-period']),
healthTimeout: _parseDurationInMs(parameters['health-timeout']),
restart: parameters['restart'],
);
if (containerInfos != null) {
await _printToConsole('CREATED CONTAINER> $containerInfos');
return true;
}
return false;
}
case 'createservice':
{
var parameters = await _requireParameters({
'serviceName': cmd.get(0, 'serviceName', 'service'),
'imageName': cmd.get(1, 'imageName', 'image'),
'version': cmd.get(2, 'version', 'ver'),
'replicas': cmd.get(3, 'replicas'),
'ports': cmd.get(4, 'ports', 'port'),
'volumes': cmd.get(5, 'volumes'),
'hostname': cmd.get(6, 'hostname', 'host'),
'network': cmd.get(7, 'network'),
'environment': cmd.get(8, 'environment', 'env'),
}, {
'containerName',
'imageName',
}, cmd.askAllProperties);
var paramPorts = await _parsePortsProperties(parameters);
var paramVolumes = await _parseVolumesProperties(parameters);
var paramEnvironment = await _parseEnvironmentProperties(parameters);
var service = await dockerCommander.createService(
parameters['serviceName']!,
parameters['imageName']!,
version: parameters['version'],
replicas: parseInt(parameters['replicas']),
ports: paramPorts,
volumes: paramVolumes,
hostname: parameters['hostname'],
network: parameters['network'],
environment: paramEnvironment,
);
if (service != null) {
await _printToConsole('CREATED SERVICE> $service');
return true;
}
return false;
}
case 'removecontainer':
{
var parameters = await _requireParameters({
'containerName': cmd.get(0, 'containerOrServiceName',
'containerName', 'container', 'serviceName', 'service'),
'force': cmd.getProperty('force'),
}, {
'containerName',
}, cmd.askAllProperties);
var ok = await dockerCommander.removeContainer(
parameters['containerName']!,
force: parseBool(parameters['force']) ?? false);
await _printToConsole('STARTED CONTAINER: $ok');
return ok;
}
case 'start':
{
var parameters = await _requireParameters({
'containerName': cmd.get(0, 'containerOrServiceName',
'containerName', 'container', 'serviceName', 'service'),
}, {
'containerName',
}, cmd.askAllProperties);
var ok = await dockerCommander
.startContainer(parameters['containerName']!);
await _printToConsole('STARTED CONTAINER: $ok');
return ok;
}
case 'stop':
{
var parameters = await _requireParameters({
'containerName': cmd.get(0, 'containerOrServiceName',
'containerName', 'container', 'serviceName', 'service'),
}, {
'containerName',
}, cmd.askAllProperties);
var ok =
await dockerCommander.stopContainer(parameters['containerName']!);
await _printToConsole('STOPPED CONTAINER: $ok');
return ok;
}
case 'log':
case 'logs':
{
cmd.defaultReturnType = ConsoleCMDReturnType.stdout;
var parameters = await _requireParameters({
'name': cmd.get(0, 'containerOrServiceName', 'containerName',
'container', 'serviceName', 'service'),
'stdout': cmd.getProperty('stdout'),
'stderr': cmd.getProperty('stderr'),
}, {
'name',
}, cmd.askAllProperties);
if (parseBool(parameters['stdout'], false)!) {
cmd.returnType = ConsoleCMDReturnType.stdout;
} else if (parseBool(parameters['stderr'], false)!) {
cmd.returnType = ConsoleCMDReturnType.stderr;
}
var name = parameters['name'];
var containersNames = await dockerCommander.psContainerNames();
await _printToConsole('CONTAINERS: $containersNames');
DockerProcess? process;
if (containersNames != null && containersNames.contains(name)) {
process = await dockerCommander.openContainerLogs(name!);
} else {
var servicesNames = await dockerCommander.listServicesNames();
await _printToConsole('SERVICES: $servicesNames');
if (servicesNames != null && servicesNames.contains(name)) {
process = await dockerCommander.openServiceLogs(name!);
} else {
return false;
}
}
return await _processReturn(cmd, process);
}
case 'execwhich':
{
cmd.returnType = ConsoleCMDReturnType.stdout;
var parameters = await _requireParameters({
'containerName': cmd.get(0, 'containerName', 'container'),
'binary': cmd.get(1, 'binaryName', 'binary'),
}, {
'containerName',
'binary',
}, cmd.askAllProperties);
var exec = await dockerCommander.execWhich(
parameters['containerName']!, parameters['binary']!);
await _printToConsole(exec);
return true;
}
case 'exec':
{
cmd.defaultReturnType = ConsoleCMDReturnType.stdout;
var parameters = await _requireParameters({
'containerName': cmd.get(0, 'containerName', 'container'),
'command': cmd.get(1, 'command', 'cmd'),
}, {
'containerName',
'command'
}, cmd.askAllProperties);
var exec = await dockerCommander.exec(parameters['containerName']!,
parameters['command'], cmd.argsSub(2));
return await _processReturn(cmd, exec);
}
case 'docker':
case 'cmd':
case 'command':
{
cmd.defaultReturnType = ConsoleCMDReturnType.stdout;
var parameters = await _requireParameters({
'command': cmd.get(0, 'command', 'cmd'),
}, {
'command'
}, cmd.askAllProperties);
var exec = await dockerCommander.command(
parameters['command']!, cmd.argsSub(1));
return await _processReturn(cmd, exec);
}
case 'listformula':
case 'listformulas':
{
var formulasNames = await dockerCommander.listFormulasNames();
await _printLineToConsole();
await _printToConsole('FORMULAS:');
await _printToConsole('');
await _printToConsole(' ${formulasNames.join(' ')}');
await _printToConsole('');
await _printLineToConsole();
return true;
}
case 'getformulaclassname':
{
var parameters = await _requireParameters({
'formulaName': cmd.get(0, 'formulaName', 'formula'),
}, {
'formulaName',
}, cmd.askAllProperties);
var formulaName = parameters['formulaName']!;
var className =
await dockerCommander.getFormulaClassName(formulaName);
await _printToConsole("'$formulaName' CLASS NAME: $className");
return true;
}
case 'listformulafunction':
case 'listformulafunctions':
{
var parameters = await _requireParameters({
'formulaName': cmd.get(0, 'formulaName', 'formula'),
}, {
'formulaName',
}, cmd.askAllProperties);
var formulaName = parameters['formulaName']!;
var functions =
await dockerCommander.listFormulasFunctions(formulaName);
await _printLineToConsole();
await _printToConsole("'$formulaName' FUNCTIONS:");
await _printToConsole('');
for (var f in functions) {
await _printToConsole(' - $f');
}
await _printToConsole('');
await _printLineToConsole();
return true;
}
case 'showformula':
{
var parameters = await _requireParameters({
'formulaName': cmd.get(0, 'formulaName', 'formula'),
}, {
'formulaName',
}, cmd.askAllProperties);
var formulaName = parameters['formulaName']!;
var fieldsFuture = dockerCommander.getFormulaFields(formulaName);
var functionsFuture =
dockerCommander.listFormulasFunctions(formulaName);
var classNameFuture =
dockerCommander.getFormulaClassName(formulaName);
var className = await classNameFuture;
var fields = await fieldsFuture;
var functions = await functionsFuture;
await _printLineToConsole();
await _printToConsole('FORMULA: $formulaName');
await _printToConsole('');
await _printToConsole('CLASS NAME: $className');
await _printToConsole('');
await _printToConsole('FIELDS:');
await _printToConsole('');
for (var entry in fields.entries) {
await _printToConsole(' - ${entry.key}: ${entry.value}');
}
await _printToConsole('');
await _printToConsole('FUNCTIONS:');
await _printToConsole('');
for (var f in functions) {
await _printToConsole(' - $f');
}
await _printToConsole('');
await _printLineToConsole();
return true;
}
case 'formulaexec':
{
var parameters = await _requireParameters({
'formulaName': cmd.get(0, 'formulaName', 'formula'),
'function': cmd.get(1, 'function'),
}, {
'formulaName',
'function',
}, cmd.askAllProperties);
var formulaName = parameters['formulaName']!;
var fName = parameters['function']!;
var arguments = cmd.argsSub(2);
var properties = cmd.properties;
var result = await dockerCommander.formulaExec(
formulaName, fName, arguments, properties);
await _printLineToConsole();
await _printToConsole(
'FORMULA EXEC: $formulaName.$fName( ${arguments.join(' , ')} )');
await _printToConsole('');
await _printToConsole('RESULT:');
await _printToConsole('$result');
await _printToConsole('');
await _printLineToConsole();
return true;
}
default:
return false;
}
}
