portainer/app/docker/helpers/serviceHelper.js

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;
  },
]);