portainer/app/docker/helpers/serviceHelper.js

252 lines
7.6 KiB
JavaScript

import moment from 'moment';
angular.module('portainer.docker').factory('ServiceHelper', [
function ServiceHelperFactory() {
'use strict';
var helper = {};
helper.associateTasksToService = function (service, tasks) {
service.Tasks = [];
var otherServicesTasks = [];
for (var i = 0; i < tasks.length; i++) {
var task = tasks[i];
if (task.ServiceId === service.Id) {
service.Tasks.push(task);
task.ServiceName = service.Name;
} else {
otherServicesTasks.push(task);
}
}
tasks = otherServicesTasks;
};
helper.serviceToConfig = function (service) {
return {
Name: service.Spec.Name,
Labels: service.Spec.Labels,
TaskTemplate: service.Spec.TaskTemplate,
Mode: service.Spec.Mode,
UpdateConfig: service.Spec.UpdateConfig,
Networks: service.Spec.Networks,
EndpointSpec: service.Spec.EndpointSpec,
};
};
helper.translateKeyValueToPlacementPreferences = function (keyValuePreferences) {
if (keyValuePreferences) {
var preferences = [];
keyValuePreferences.forEach(function (preference) {
if (preference.strategy && preference.strategy !== '' && preference.value && preference.value !== '') {
switch (preference.strategy.toLowerCase()) {
case 'spread':
preferences.push({
Spread: {
SpreadDescriptor: preference.value,
},
});
break;
}
}
});
return preferences;
}
return [];
};
helper.translateKeyValueToPlacementConstraints = function (keyValueConstraints) {
if (keyValueConstraints) {
var constraints = [];
keyValueConstraints.forEach(function (constraint) {
if (constraint.key && constraint.key !== '' && constraint.value && constraint.value !== '') {
constraints.push(constraint.key + constraint.operator + constraint.value);
}
});
return constraints;
}
return [];
};
helper.translateEnvironmentVariables = function (env) {
if (env) {
var variables = [];
env.forEach(function (variable) {
var idx = variable.indexOf('=');
var keyValue = [variable.slice(0, idx), variable.slice(idx + 1)];
var originalValue = keyValue.length > 1 ? keyValue[1] : '';
variables.push({
key: keyValue[0],
value: originalValue,
originalKey: keyValue[0],
originalValue: originalValue,
added: true,
});
});
return variables;
}
return [];
};
helper.translateEnvironmentVariablesToEnv = function (env) {
if (env) {
var variables = [];
env.forEach(function (variable) {
if (variable.key && variable.key !== '') {
variables.push(variable.key + '=' + variable.value);
}
});
return variables;
}
return [];
};
helper.translatePreferencesToKeyValue = function (preferences) {
if (preferences) {
var keyValuePreferences = [];
preferences.forEach(function (preference) {
if (preference.Spread) {
keyValuePreferences.push({
strategy: 'Spread',
value: preference.Spread.SpreadDescriptor,
});
}
});
return keyValuePreferences;
}
return [];
};
helper.translateConstraintsToKeyValue = function (constraints) {
function getOperator(constraint) {
var indexEquals = constraint.indexOf('==');
if (indexEquals >= 0) {
return [indexEquals, '=='];
}
return [constraint.indexOf('!='), '!='];
}
if (constraints) {
var keyValueConstraints = [];
constraints.forEach(function (constraint) {
var operatorIndices = getOperator(constraint);
var key = constraint.slice(0, operatorIndices[0]);
var operator = operatorIndices[1];
var value = constraint.slice(operatorIndices[0] + 2);
keyValueConstraints.push({
key: key,
value: value,
operator: operator,
originalKey: key,
originalValue: value,
});
});
return keyValueConstraints;
}
};
helper.translateHumanDurationToNanos = function (humanDuration) {
var nanos;
var regex = /^([0-9]+)(h|m|s|ms|us|ns)$/i;
var matches = humanDuration.match(regex);
if (matches !== null && matches.length === 3) {
var duration = parseInt(matches[1], 10);
var unit = matches[2];
// Moment.js cannot use micro or nanoseconds
switch (unit) {
case 'ns':
nanos = duration;
break;
case 'us':
nanos = duration * 1000;
break;
default:
nanos = moment.duration(duration, unit).asMilliseconds() * 1000000;
}
}
return nanos;
};
// Convert nanoseconds to the higher unit possible
// e.g 1840 nanoseconds = 1804ns
// e.g 300000000000 nanoseconds = 5m
// e.g 3510000000000 nanoseconds = 3510s
// e.g 3540000000000 nanoseconds = 59m
// e.g 3600000000000 nanoseconds = 1h
helper.translateNanosToHumanDuration = function (nanos) {
var humanDuration = '0s';
var conversionFromNano = {};
conversionFromNano['ns'] = 1;
conversionFromNano['us'] = conversionFromNano['ns'] * 1000;
conversionFromNano['ms'] = conversionFromNano['us'] * 1000;
conversionFromNano['s'] = conversionFromNano['ms'] * 1000;
conversionFromNano['m'] = conversionFromNano['s'] * 60;
conversionFromNano['h'] = conversionFromNano['m'] * 60;
Object.keys(conversionFromNano).forEach(function (unit) {
if (nanos % conversionFromNano[unit] === 0 && nanos / conversionFromNano[unit] > 0) {
humanDuration = nanos / conversionFromNano[unit] + unit;
}
});
return humanDuration;
};
helper.translateLogDriverOptsToKeyValue = function (logOptions) {
var options = [];
if (logOptions) {
Object.keys(logOptions).forEach(function (key) {
options.push({
key: key,
value: logOptions[key],
originalKey: key,
originalValue: logOptions[key],
added: true,
});
});
}
return options;
};
helper.translateKeyValueToLogDriverOpts = function (keyValueLogDriverOpts) {
var options = {};
if (keyValueLogDriverOpts) {
keyValueLogDriverOpts.forEach(function (option) {
if (option.key && option.key !== '' && option.value && option.value !== '') {
options[option.key] = option.value;
}
});
}
return options;
};
helper.translateHostsEntriesToHostnameIP = function (entries) {
var ipHostEntries = [];
if (entries) {
entries.forEach(function (entry) {
if (entry.indexOf(' ') && entry.split(' ').length === 2) {
var keyValue = entry.split(' ');
ipHostEntries.push({ hostname: keyValue[1], ip: keyValue[0] });
}
});
}
return ipHostEntries;
};
helper.translateHostnameIPToHostsEntries = function (entries) {
var ipHostEntries = [];
if (entries) {
entries.forEach(function (entry) {
if (entry.ip && entry.hostname) {
ipHostEntries.push(entry.ip + ' ' + entry.hostname);
}
});
}
return ipHostEntries;
};
return helper;
},
]);