1
0
Fork 0
mirror of https://github.com/portainer/portainer.git synced 2025-08-05 13:55:21 +02:00

chore(project): add prettier for code format (#3645)

* chore(project): install prettier and lint-staged

* chore(project): apply prettier to html too

* chore(project): git ignore eslintcache

* chore(project): add a comment about format script

* chore(prettier): update printWidth

* chore(prettier): remove useTabs option

* chore(prettier): add HTML validation

* refactor(prettier): fix closing tags

* feat(prettier): define angular parser for html templates

* style(prettier): run prettier on codebase

Co-authored-by: Anthony Lapenna <lapenna.anthony@gmail.com>
This commit is contained in:
Chaim Lev-Ari 2020-04-11 00:54:53 +03:00 committed by GitHub
parent 6663073be1
commit cf5056d9c0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
714 changed files with 31228 additions and 28305 deletions

View file

@ -1,67 +1,71 @@
import { ImageBuildModel } from "../models/image";
import { ImageBuildModel } from '../models/image';
angular.module('portainer.docker')
.factory('BuildService', ['$q', 'Build', 'FileUploadService', function BuildServiceFactory($q, Build, FileUploadService) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('BuildService', [
'$q',
'Build',
'FileUploadService',
function BuildServiceFactory($q, Build, FileUploadService) {
'use strict';
var service = {};
service.buildImageFromUpload = function(names, file, path) {
var deferred = $q.defer();
service.buildImageFromUpload = function (names, file, path) {
var deferred = $q.defer();
FileUploadService.buildImage(names, file, path)
.then(function success(response) {
var model = new ImageBuildModel(response.data);
deferred.resolve(model);
})
.catch(function error(err) {
deferred.reject(err);
});
FileUploadService.buildImage(names, file, path)
.then(function success(response) {
var model = new ImageBuildModel(response.data);
deferred.resolve(model);
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
service.buildImageFromURL = function(names, url, path) {
var params = {
t: names,
remote: url,
dockerfile: path
return deferred.promise;
};
var deferred = $q.defer();
service.buildImageFromURL = function (names, url, path) {
var params = {
t: names,
remote: url,
dockerfile: path,
};
Build.buildImage(params, {}).$promise
.then(function success(data) {
var model = new ImageBuildModel(data);
deferred.resolve(model);
})
.catch(function error(err) {
deferred.reject(err);
});
var deferred = $q.defer();
return deferred.promise;
};
Build.buildImage(params, {})
.$promise.then(function success(data) {
var model = new ImageBuildModel(data);
deferred.resolve(model);
})
.catch(function error(err) {
deferred.reject(err);
});
service.buildImageFromDockerfileContent = function(names, content) {
var params = {
t: names
};
var payload = {
content: content
return deferred.promise;
};
var deferred = $q.defer();
service.buildImageFromDockerfileContent = function (names, content) {
var params = {
t: names,
};
var payload = {
content: content,
};
Build.buildImageOverride(params, payload).$promise
.then(function success(data) {
var model = new ImageBuildModel(data);
deferred.resolve(model);
})
.catch(function error(err) {
deferred.reject(err);
});
var deferred = $q.defer();
return deferred.promise;
};
Build.buildImageOverride(params, payload)
.$promise.then(function success(data) {
var model = new ImageBuildModel(data);
deferred.resolve(model);
})
.catch(function error(err) {
deferred.reject(err);
});
return service;
}]);
return deferred.promise;
};
return service;
},
]);

View file

@ -1,63 +1,66 @@
import { ConfigViewModel } from '../models/config';
angular.module('portainer.docker')
.factory('ConfigService', ['$q', 'Config', function ConfigServiceFactory($q, Config) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('ConfigService', [
'$q',
'Config',
function ConfigServiceFactory($q, Config) {
'use strict';
var service = {};
service.config = function(configId) {
var deferred = $q.defer();
service.config = function (configId) {
var deferred = $q.defer();
Config.get({id: configId}).$promise
.then(function success(data) {
var config = new ConfigViewModel(data);
deferred.resolve(config);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve config details', err: err });
});
Config.get({ id: configId })
.$promise.then(function success(data) {
var config = new ConfigViewModel(data);
deferred.resolve(config);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve config details', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.configs = function() {
var deferred = $q.defer();
service.configs = function () {
var deferred = $q.defer();
Config.query({}).$promise
.then(function success(data) {
var configs = data.map(function (item) {
return new ConfigViewModel(item);
});
deferred.resolve(configs);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve configs', err: err });
});
Config.query({})
.$promise.then(function success(data) {
var configs = data.map(function (item) {
return new ConfigViewModel(item);
});
deferred.resolve(configs);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve configs', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.remove = function(configId) {
var deferred = $q.defer();
service.remove = function (configId) {
var deferred = $q.defer();
Config.remove({ id: configId }).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove config', err: err });
});
Config.remove({ id: configId })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove config', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.create = function(config) {
return Config.create(config).$promise;
};
service.create = function (config) {
return Config.create(config).$promise;
};
return service;
}]);
return service;
},
]);

View file

@ -1,213 +1,217 @@
import { ContainerDetailsViewModel, ContainerViewModel, ContainerStatsViewModel } from '../models/container';
angular.module('portainer.docker')
.factory('ContainerService', ['$q', 'Container', 'ResourceControlService', 'LogHelper', '$timeout',
function ContainerServiceFactory($q, Container, ResourceControlService, LogHelper, $timeout) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('ContainerService', [
'$q',
'Container',
'ResourceControlService',
'LogHelper',
'$timeout',
function ContainerServiceFactory($q, Container, ResourceControlService, LogHelper, $timeout) {
'use strict';
var service = {};
service.container = function(id) {
var deferred = $q.defer();
service.container = function (id) {
var deferred = $q.defer();
Container.get({ id: id }).$promise
.then(function success(data) {
var container = new ContainerDetailsViewModel(data);
deferred.resolve(container);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve container information', err: err });
});
Container.get({ id: id })
.$promise.then(function success(data) {
var container = new ContainerDetailsViewModel(data);
deferred.resolve(container);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve container information', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.containers = function(all, filters) {
var deferred = $q.defer();
Container.query({ all : all, filters: filters }).$promise
.then(function success(data) {
var containers = data.map(function (item) {
return new ContainerViewModel(item);
});
deferred.resolve(containers);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve containers', err: err });
});
service.containers = function (all, filters) {
var deferred = $q.defer();
Container.query({ all: all, filters: filters })
.$promise.then(function success(data) {
var containers = data.map(function (item) {
return new ContainerViewModel(item);
});
deferred.resolve(containers);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve containers', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.resizeTTY = function (id, width, height, timeout) {
var deferred = $q.defer();
service.resizeTTY = function (id, width, height, timeout) {
var deferred = $q.defer();
$timeout(function() {
Container.resize({}, {id: id, height: height, width: width}).$promise
.then(function success(data) {
$timeout(function () {
Container.resize({}, { id: id, height: height, width: width })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({msg: 'Unable to resize tty of container ' + id, err: data.message});
deferred.reject({ msg: 'Unable to resize tty of container ' + id, err: data.message });
} else {
deferred.resolve(data);
}
})
.catch(function error(err) {
deferred.reject({msg: 'Unable to resize tty of container ' + id, err: err});
deferred.reject({ msg: 'Unable to resize tty of container ' + id, err: err });
});
}, timeout);
}, timeout);
return deferred.promise;
};
service.startContainer = function(id) {
return Container.start({ id: id }, {}).$promise;
};
service.stopContainer = function(id) {
return Container.stop({ id: id }, {}).$promise;
};
service.restartContainer = function(id) {
return Container.restart({ id: id }, {}).$promise;
};
service.killContainer = function(id) {
return Container.kill({ id: id }, {}).$promise;
};
service.pauseContainer = function(id) {
return Container.pause({ id: id }, {}).$promise;
};
service.resumeContainer = function(id) {
return Container.unpause({ id: id }, {}).$promise;
};
service.renameContainer = function(id, newContainerName) {
return Container.rename({id: id, name: newContainerName }, {}).$promise;
};
service.updateRestartPolicy = updateRestartPolicy;
function updateRestartPolicy(id, restartPolicy, maximumRetryCounts) {
return Container.update({ id: id },
{ RestartPolicy: { Name: restartPolicy, MaximumRetryCount: maximumRetryCounts } }
).$promise;
}
service.createContainer = function(configuration) {
var deferred = $q.defer();
Container.create(configuration).$promise
.then(function success(data) {
deferred.resolve(data);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to create container', err: err });
});
return deferred.promise;
};
service.createAndStartContainer = function(configuration) {
var deferred = $q.defer();
var container;
service.createContainer(configuration)
.then(function success(data) {
container = data;
return service.startContainer(container.Id);
})
.then(function success() {
deferred.resolve(container);
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
service.remove = function(container, removeVolumes) {
var deferred = $q.defer();
Container.remove({ id: container.Id, v: (removeVolumes) ? 1 : 0, force: true }).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove container', err: err });
});
return deferred.promise;
};
service.createExec = function(execConfig) {
var deferred = $q.defer();
Container.exec({}, execConfig).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve(data);
}
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
service.logs = function(id, stdout, stderr, timestamps, since, tail, stripHeaders) {
var deferred = $q.defer();
var parameters = {
id: id,
stdout: stdout || 0,
stderr: stderr || 0,
timestamps: timestamps || 0,
since: since || 0,
tail: tail || 'all'
return deferred.promise;
};
Container.logs(parameters).$promise
.then(function success(data) {
var logs = LogHelper.formatLogs(data.logs, stripHeaders);
deferred.resolve(logs);
})
.catch(function error(err) {
deferred.reject(err);
});
service.startContainer = function (id) {
return Container.start({ id: id }, {}).$promise;
};
return deferred.promise;
};
service.stopContainer = function (id) {
return Container.stop({ id: id }, {}).$promise;
};
service.containerStats = function(id) {
var deferred = $q.defer();
service.restartContainer = function (id) {
return Container.restart({ id: id }, {}).$promise;
};
Container.stats({ id: id }).$promise
.then(function success(data) {
var containerStats = new ContainerStatsViewModel(data);
deferred.resolve(containerStats);
})
.catch(function error(err) {
deferred.reject(err);
});
service.killContainer = function (id) {
return Container.kill({ id: id }, {}).$promise;
};
return deferred.promise;
};
service.pauseContainer = function (id) {
return Container.pause({ id: id }, {}).$promise;
};
service.containerTop = function(id) {
return Container.top({ id: id }).$promise;
};
service.resumeContainer = function (id) {
return Container.unpause({ id: id }, {}).$promise;
};
service.inspect = function(id) {
return Container.inspect({ id: id }).$promise;
};
service.renameContainer = function (id, newContainerName) {
return Container.rename({ id: id, name: newContainerName }, {}).$promise;
};
service.prune = function(filters) {
return Container.prune({ filters: filters }).$promise;
};
service.updateRestartPolicy = updateRestartPolicy;
return service;
}]);
function updateRestartPolicy(id, restartPolicy, maximumRetryCounts) {
return Container.update({ id: id }, { RestartPolicy: { Name: restartPolicy, MaximumRetryCount: maximumRetryCounts } }).$promise;
}
service.createContainer = function (configuration) {
var deferred = $q.defer();
Container.create(configuration)
.$promise.then(function success(data) {
deferred.resolve(data);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to create container', err: err });
});
return deferred.promise;
};
service.createAndStartContainer = function (configuration) {
var deferred = $q.defer();
var container;
service
.createContainer(configuration)
.then(function success(data) {
container = data;
return service.startContainer(container.Id);
})
.then(function success() {
deferred.resolve(container);
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
service.remove = function (container, removeVolumes) {
var deferred = $q.defer();
Container.remove({ id: container.Id, v: removeVolumes ? 1 : 0, force: true })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove container', err: err });
});
return deferred.promise;
};
service.createExec = function (execConfig) {
var deferred = $q.defer();
Container.exec({}, execConfig)
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve(data);
}
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
service.logs = function (id, stdout, stderr, timestamps, since, tail, stripHeaders) {
var deferred = $q.defer();
var parameters = {
id: id,
stdout: stdout || 0,
stderr: stderr || 0,
timestamps: timestamps || 0,
since: since || 0,
tail: tail || 'all',
};
Container.logs(parameters)
.$promise.then(function success(data) {
var logs = LogHelper.formatLogs(data.logs, stripHeaders);
deferred.resolve(logs);
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
service.containerStats = function (id) {
var deferred = $q.defer();
Container.stats({ id: id })
.$promise.then(function success(data) {
var containerStats = new ContainerStatsViewModel(data);
deferred.resolve(containerStats);
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
service.containerTop = function (id) {
return Container.top({ id: id }).$promise;
};
service.inspect = function (id) {
return Container.inspect({ id: id }).$promise;
};
service.prune = function (filters) {
return Container.prune({ filters: filters }).$promise;
};
return service;
},
]);

View file

@ -1,27 +1,31 @@
angular.module('portainer.docker')
.factory('ExecService', ['$q', '$timeout', 'Exec', function ExecServiceFactory($q, $timeout, Exec) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('ExecService', [
'$q',
'$timeout',
'Exec',
function ExecServiceFactory($q, $timeout, Exec) {
'use strict';
var service = {};
service.resizeTTY = function (execId, width, height, timeout) {
var deferred = $q.defer();
service.resizeTTY = function (execId, width, height, timeout) {
var deferred = $q.defer();
$timeout(function() {
Exec.resize({}, {id: execId, height: height, width: width}).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({msg: "Unable to resize tty of exec", err: data.message});
} else {
deferred.resolve(data);
}
})
.catch(function error(err) {
deferred.reject({msg: "Unable to resize tty of exec", err: err});
});
}, timeout);
$timeout(function () {
Exec.resize({}, { id: execId, height: height, width: width })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: 'Unable to resize tty of exec', err: data.message });
} else {
deferred.resolve(data);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to resize tty of exec', err: err });
});
}, timeout);
return deferred.promise;
};
return deferred.promise;
};
return service;
}]);
return service;
},
]);

View file

@ -1,205 +1,212 @@
import _ from 'lodash-es';
import { ImageViewModel } from '../models/image';
import { ImageDetailsViewModel } from "../models/imageDetails";
import { ImageLayerViewModel } from "../models/imageLayer";
import { ImageDetailsViewModel } from '../models/imageDetails';
import { ImageLayerViewModel } from '../models/imageLayer';
angular.module('portainer.docker')
.factory('ImageService', ['$q', 'Image', 'ImageHelper', 'RegistryService', 'HttpRequestHelper', 'ContainerService', 'FileUploadService',
angular.module('portainer.docker').factory('ImageService', [
'$q',
'Image',
'ImageHelper',
'RegistryService',
'HttpRequestHelper',
'ContainerService',
'FileUploadService',
function ImageServiceFactory($q, Image, ImageHelper, RegistryService, HttpRequestHelper, ContainerService, FileUploadService) {
'use strict';
var service = {};
'use strict';
var service = {};
service.image = function(imageId) {
var deferred = $q.defer();
Image.get({id: imageId}).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
var image = new ImageDetailsViewModel(data);
deferred.resolve(image);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve image details', err: err });
});
return deferred.promise;
};
service.images = function(withUsage) {
var deferred = $q.defer();
$q.all({
containers: withUsage ? ContainerService.containers(1) : [],
images: Image.query({}).$promise
})
.then(function success(data) {
var containers = data.containers;
var images = data.images.map(function(item) {
item.ContainerCount = 0;
for (var i = 0; i < containers.length; i++) {
var container = containers[i];
if (container.ImageID === item.Id) {
item.ContainerCount++;
service.image = function (imageId) {
var deferred = $q.defer();
Image.get({ id: imageId })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
var image = new ImageDetailsViewModel(data);
deferred.resolve(image);
}
}
return new ImageViewModel(item);
});
deferred.resolve(images);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve images', err: err });
});
return deferred.promise;
};
service.history = function(imageId) {
var deferred = $q.defer();
Image.history({id: imageId}).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
var layers = [];
var order = data.length;
angular.forEach(data, function(imageLayer) {
layers.push(new ImageLayerViewModel(order, imageLayer));
order--;
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve image details', err: err });
});
deferred.resolve(layers);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve image details', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.pushImage = pushImage;
/**
*
* @param {PorImageRegistryModel} registryModel
*/
function pushImage(registryModel) {
var deferred = $q.defer();
service.images = function (withUsage) {
var deferred = $q.defer();
var authenticationDetails = registryModel.Registry.Authentication ? RegistryService.encodedCredentials(registryModel.Registry) : '';
HttpRequestHelper.setRegistryAuthenticationHeader(authenticationDetails);
$q.all({
containers: withUsage ? ContainerService.containers(1) : [],
images: Image.query({}).$promise,
})
.then(function success(data) {
var containers = data.containers;
const imageConfiguration = ImageHelper.createImageConfigForContainer(registryModel);
var images = data.images.map(function (item) {
item.ContainerCount = 0;
for (var i = 0; i < containers.length; i++) {
var container = containers[i];
if (container.ImageID === item.Id) {
item.ContainerCount++;
}
}
return new ImageViewModel(item);
});
Image.push({imageName: imageConfiguration.fromImage}).$promise
.then(function success(data) {
if (data[data.length - 1].error) {
deferred.reject({ msg: data[data.length - 1].error });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to push image tag', err: err });
});
return deferred.promise;
}
deferred.resolve(images);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve images', err: err });
});
return deferred.promise;
};
/**
* PULL IMAGE
*/
service.history = function (imageId) {
var deferred = $q.defer();
Image.history({ id: imageId })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
var layers = [];
var order = data.length;
angular.forEach(data, function (imageLayer) {
layers.push(new ImageLayerViewModel(order, imageLayer));
order--;
});
deferred.resolve(layers);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve image details', err: err });
});
return deferred.promise;
};
function pullImageAndIgnoreErrors(imageConfiguration) {
var deferred = $q.defer();
service.pushImage = pushImage;
/**
*
* @param {PorImageRegistryModel} registryModel
*/
function pushImage(registryModel) {
var deferred = $q.defer();
Image.create({}, imageConfiguration).$promise
.finally(function final() {
deferred.resolve();
});
var authenticationDetails = registryModel.Registry.Authentication ? RegistryService.encodedCredentials(registryModel.Registry) : '';
HttpRequestHelper.setRegistryAuthenticationHeader(authenticationDetails);
return deferred.promise;
}
const imageConfiguration = ImageHelper.createImageConfigForContainer(registryModel);
function pullImageAndAcknowledgeErrors(imageConfiguration) {
var deferred = $q.defer();
Image.create({}, imageConfiguration).$promise
.then(function success(data) {
var err = data.length > 0 && data[data.length - 1].hasOwnProperty('message');
if (err) {
var detail = data[data.length - 1];
deferred.reject({ msg: detail.message });
} else {
deferred.resolve(data);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to pull image', err: err });
});
return deferred.promise;
}
service.pullImage = pullImage;
/**
*
* @param {PorImageRegistryModel} registry
* @param {bool} ignoreErrors
*/
function pullImage(registry, ignoreErrors) {
var authenticationDetails = registry.Registry.Authentication ? RegistryService.encodedCredentials(registry.Registry) : '';
HttpRequestHelper.setRegistryAuthenticationHeader(authenticationDetails);
var imageConfiguration = ImageHelper.createImageConfigForContainer(registry);
if (ignoreErrors) {
return pullImageAndIgnoreErrors(imageConfiguration);
Image.push({ imageName: imageConfiguration.fromImage })
.$promise.then(function success(data) {
if (data[data.length - 1].error) {
deferred.reject({ msg: data[data.length - 1].error });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to push image tag', err: err });
});
return deferred.promise;
}
return pullImageAndAcknowledgeErrors(imageConfiguration);
}
/**
* ! PULL IMAGE
*/
/**
* PULL IMAGE
*/
service.tagImage = function(id, image) {
return Image.tag({id: id, repo: image}).$promise;
};
function pullImageAndIgnoreErrors(imageConfiguration) {
var deferred = $q.defer();
service.downloadImages = function(images) {
var names = ImageHelper.getImagesNamesForDownload(images);
return Image.download(names).$promise;
};
service.uploadImage = function(file) {
return FileUploadService.loadImages(file);
};
service.deleteImage = function(id, forceRemoval) {
var deferred = $q.defer();
Image.remove({id: id, force: forceRemoval}).$promise
.then(function success(data) {
if (data[0].message) {
deferred.reject({ msg: data[0].message });
} else {
Image.create({}, imageConfiguration).$promise.finally(function final() {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove image', err: err });
});
return deferred.promise;
};
service.getUniqueTagListFromImages = function (availableImages) {
return _.uniq(_.flatMap(availableImages, function (image) {
_.remove(image.RepoTags, function (item) {
return item.indexOf('<none>') !== -1;
});
return image.RepoTags ? _.uniqWith(image.RepoTags, _.isEqual) : [];
}));
};
return service;
}]);
return deferred.promise;
}
function pullImageAndAcknowledgeErrors(imageConfiguration) {
var deferred = $q.defer();
Image.create({}, imageConfiguration)
.$promise.then(function success(data) {
var err = data.length > 0 && data[data.length - 1].hasOwnProperty('message');
if (err) {
var detail = data[data.length - 1];
deferred.reject({ msg: detail.message });
} else {
deferred.resolve(data);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to pull image', err: err });
});
return deferred.promise;
}
service.pullImage = pullImage;
/**
*
* @param {PorImageRegistryModel} registry
* @param {bool} ignoreErrors
*/
function pullImage(registry, ignoreErrors) {
var authenticationDetails = registry.Registry.Authentication ? RegistryService.encodedCredentials(registry.Registry) : '';
HttpRequestHelper.setRegistryAuthenticationHeader(authenticationDetails);
var imageConfiguration = ImageHelper.createImageConfigForContainer(registry);
if (ignoreErrors) {
return pullImageAndIgnoreErrors(imageConfiguration);
}
return pullImageAndAcknowledgeErrors(imageConfiguration);
}
/**
* ! PULL IMAGE
*/
service.tagImage = function (id, image) {
return Image.tag({ id: id, repo: image }).$promise;
};
service.downloadImages = function (images) {
var names = ImageHelper.getImagesNamesForDownload(images);
return Image.download(names).$promise;
};
service.uploadImage = function (file) {
return FileUploadService.loadImages(file);
};
service.deleteImage = function (id, forceRemoval) {
var deferred = $q.defer();
Image.remove({ id: id, force: forceRemoval })
.$promise.then(function success(data) {
if (data[0].message) {
deferred.reject({ msg: data[0].message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove image', err: err });
});
return deferred.promise;
};
service.getUniqueTagListFromImages = function (availableImages) {
return _.uniq(
_.flatMap(availableImages, function (image) {
_.remove(image.RepoTags, function (item) {
return item.indexOf('<none>') !== -1;
});
return image.RepoTags ? _.uniqWith(image.RepoTags, _.isEqual) : [];
})
);
};
return service;
},
]);

View file

@ -1,87 +1,92 @@
import { NetworkViewModel } from '../models/network';
angular.module('portainer.docker')
.factory('NetworkService', ['$q', 'Network', function NetworkServiceFactory($q, Network) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('NetworkService', [
'$q',
'Network',
function NetworkServiceFactory($q, Network) {
'use strict';
var service = {};
service.create = function(networkConfiguration) {
var deferred = $q.defer();
service.create = function (networkConfiguration) {
var deferred = $q.defer();
Network.create(networkConfiguration).$promise
.then(function success(data) {
deferred.resolve(data);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to create network', err: err });
});
return deferred.promise;
};
service.network = function(id) {
var deferred = $q.defer();
Network.get({ id: id }).$promise
.then(function success(data) {
var network = new NetworkViewModel(data);
deferred.resolve(network);
})
.catch(function error(err) {
deferred.reject({msg: 'Unable to retrieve network details', err: err});
});
return deferred.promise;
};
service.networks = function(localNetworks, swarmNetworks, swarmAttachableNetworks, filters) {
var deferred = $q.defer();
Network.query({ filters: filters }).$promise
.then(function success(data) {
var networks = data;
var filteredNetworks = networks.filter(function(network) {
if (localNetworks && network.Scope === 'local') {
return network;
}
if (swarmNetworks && network.Scope === 'swarm') {
return network;
}
if (swarmAttachableNetworks && network.Scope === 'swarm' && network.Attachable === true) {
return network;
}
}).map(function (item) {
return new NetworkViewModel(item);
});
deferred.resolve(filteredNetworks);
})
.catch(function error(err) {
deferred.reject({msg: 'Unable to retrieve networks', err: err});
});
return deferred.promise;
};
service.remove = function(id) {
return Network.remove({ id: id }).$promise;
};
service.disconnectContainer = function(networkId, containerId, force) {
return Network.disconnect({ id: networkId }, { Container: containerId, Force: force }).$promise;
};
service.connectContainer = function(networkId, containerId, aliases) {
var payload = {
Container: containerId,
Network.create(networkConfiguration)
.$promise.then(function success(data) {
deferred.resolve(data);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to create network', err: err });
});
return deferred.promise;
};
if (aliases) {
payload.EndpointConfig = {
Aliases: aliases,
}
}
return Network.connect({ id: networkId }, payload).$promise;
};
return service;
}]);
service.network = function (id) {
var deferred = $q.defer();
Network.get({ id: id })
.$promise.then(function success(data) {
var network = new NetworkViewModel(data);
deferred.resolve(network);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve network details', err: err });
});
return deferred.promise;
};
service.networks = function (localNetworks, swarmNetworks, swarmAttachableNetworks, filters) {
var deferred = $q.defer();
Network.query({ filters: filters })
.$promise.then(function success(data) {
var networks = data;
var filteredNetworks = networks
.filter(function (network) {
if (localNetworks && network.Scope === 'local') {
return network;
}
if (swarmNetworks && network.Scope === 'swarm') {
return network;
}
if (swarmAttachableNetworks && network.Scope === 'swarm' && network.Attachable === true) {
return network;
}
})
.map(function (item) {
return new NetworkViewModel(item);
});
deferred.resolve(filteredNetworks);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve networks', err: err });
});
return deferred.promise;
};
service.remove = function (id) {
return Network.remove({ id: id }).$promise;
};
service.disconnectContainer = function (networkId, containerId, force) {
return Network.disconnect({ id: networkId }, { Container: containerId, Force: force }).$promise;
};
service.connectContainer = function (networkId, containerId, aliases) {
var payload = {
Container: containerId,
};
if (aliases) {
payload.EndpointConfig = {
Aliases: aliases,
};
}
return Network.connect({ id: networkId }, payload).$promise;
};
return service;
},
]);

View file

@ -1,7 +1,8 @@
import { NodeViewModel } from '../models/node';
angular.module('portainer.docker').factory('NodeService', [
'$q', 'Node',
'$q',
'Node',
function NodeServiceFactory($q, Node) {
'use strict';
var service = {};
@ -30,7 +31,7 @@ angular.module('portainer.docker').factory('NodeService', [
Node.query({})
.$promise.then(function success(data) {
var nodes = data.map(function(item) {
var nodes = data.map(function (item) {
return new NodeViewModel(item);
});
deferred.resolve(nodes);
@ -49,7 +50,8 @@ angular.module('portainer.docker').factory('NodeService', [
function getActiveManager() {
var deferred = $q.defer();
service.nodes()
service
.nodes()
.then(function success(data) {
for (var i = 0; i < data.length; ++i) {
var node = data[i];
@ -67,5 +69,5 @@ angular.module('portainer.docker').factory('NodeService', [
}
return service;
}
},
]);

View file

@ -1,72 +1,76 @@
import _ from 'lodash-es';
import { PluginViewModel } from "../models/plugin";
import { PluginViewModel } from '../models/plugin';
angular.module('portainer.docker')
.factory('PluginService', ['$q', 'Plugin', 'SystemService', function PluginServiceFactory($q, Plugin, SystemService) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('PluginService', [
'$q',
'Plugin',
'SystemService',
function PluginServiceFactory($q, Plugin, SystemService) {
'use strict';
var service = {};
service.plugins = function() {
var deferred = $q.defer();
var plugins = [];
service.plugins = function () {
var deferred = $q.defer();
var plugins = [];
Plugin.query({}).$promise
.then(function success(data) {
for (var i = 0; i < data.length; i++) {
var plugin = new PluginViewModel(data[i]);
plugins.push(plugin);
}
})
.finally(function final() {
deferred.resolve(plugins);
});
Plugin.query({})
.$promise.then(function success(data) {
for (var i = 0; i < data.length; i++) {
var plugin = new PluginViewModel(data[i]);
plugins.push(plugin);
}
})
.finally(function final() {
deferred.resolve(plugins);
});
return deferred.promise;
};
return deferred.promise;
};
function servicePlugins(systemOnly, pluginType, pluginVersion) {
var deferred = $q.defer();
function servicePlugins(systemOnly, pluginType, pluginVersion) {
var deferred = $q.defer();
$q.all({
system: SystemService.plugins(),
plugins: systemOnly ? [] : service.plugins()
})
.then(function success(data) {
var aggregatedPlugins = [];
var systemPlugins = data.system;
var plugins = data.plugins;
$q.all({
system: SystemService.plugins(),
plugins: systemOnly ? [] : service.plugins(),
})
.then(function success(data) {
var aggregatedPlugins = [];
var systemPlugins = data.system;
var plugins = data.plugins;
if (systemPlugins[pluginType]) {
aggregatedPlugins = aggregatedPlugins.concat(systemPlugins[pluginType]);
}
if (systemPlugins[pluginType]) {
aggregatedPlugins = aggregatedPlugins.concat(systemPlugins[pluginType]);
}
for (var i = 0; i < plugins.length; i++) {
var plugin = plugins[i];
if (plugin.Enabled && _.includes(plugin.Config.Interface.Types, pluginVersion)) {
aggregatedPlugins.push(plugin.Name);
}
}
for (var i = 0; i < plugins.length; i++) {
var plugin = plugins[i];
if (plugin.Enabled && _.includes(plugin.Config.Interface.Types, pluginVersion)) {
aggregatedPlugins.push(plugin.Name);
}
}
deferred.resolve(aggregatedPlugins);
})
.catch(function error(err) {
deferred.reject({ msg: err.msg, err: err });
});
deferred.resolve(aggregatedPlugins);
})
.catch(function error(err) {
deferred.reject({ msg: err.msg, err: err });
});
return deferred.promise;
}
return deferred.promise;
}
service.volumePlugins = function(systemOnly) {
return servicePlugins(systemOnly, 'Volume', 'docker.volumedriver/1.0');
};
service.volumePlugins = function (systemOnly) {
return servicePlugins(systemOnly, 'Volume', 'docker.volumedriver/1.0');
};
service.networkPlugins = function(systemOnly) {
return servicePlugins(systemOnly, 'Network', 'docker.networkdriver/1.0');
};
service.networkPlugins = function (systemOnly) {
return servicePlugins(systemOnly, 'Network', 'docker.networkdriver/1.0');
};
service.loggingPlugins = function(systemOnly) {
return servicePlugins(systemOnly, 'Log', 'docker.logdriver/1.0');
};
service.loggingPlugins = function (systemOnly) {
return servicePlugins(systemOnly, 'Log', 'docker.logdriver/1.0');
};
return service;
}]);
return service;
},
]);

View file

@ -1,63 +1,66 @@
import { SecretViewModel } from '../models/secret';
angular.module('portainer.docker')
.factory('SecretService', ['$q', 'Secret', function SecretServiceFactory($q, Secret) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('SecretService', [
'$q',
'Secret',
function SecretServiceFactory($q, Secret) {
'use strict';
var service = {};
service.secret = function(secretId) {
var deferred = $q.defer();
service.secret = function (secretId) {
var deferred = $q.defer();
Secret.get({id: secretId}).$promise
.then(function success(data) {
var secret = new SecretViewModel(data);
deferred.resolve(secret);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve secret details', err: err });
});
Secret.get({ id: secretId })
.$promise.then(function success(data) {
var secret = new SecretViewModel(data);
deferred.resolve(secret);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve secret details', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.secrets = function() {
var deferred = $q.defer();
service.secrets = function () {
var deferred = $q.defer();
Secret.query({}).$promise
.then(function success(data) {
var secrets = data.map(function (item) {
return new SecretViewModel(item);
});
deferred.resolve(secrets);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve secrets', err: err });
});
Secret.query({})
.$promise.then(function success(data) {
var secrets = data.map(function (item) {
return new SecretViewModel(item);
});
deferred.resolve(secrets);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve secrets', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.remove = function(secretId) {
var deferred = $q.defer();
service.remove = function (secretId) {
var deferred = $q.defer();
Secret.remove({ id: secretId }).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove secret', err: err });
});
Secret.remove({ id: secretId })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove secret', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.create = function(secretConfig) {
return Secret.create(secretConfig).$promise;
};
service.create = function (secretConfig) {
return Secret.create(secretConfig).$promise;
};
return service;
}]);
return service;
},
]);

View file

@ -1,98 +1,103 @@
import { ServiceViewModel } from '../models/service';
angular.module('portainer.docker').factory('ServiceService', [
'$q',
'Service',
'ServiceHelper',
'TaskService',
'ResourceControlService',
'LogHelper',
function ServiceServiceFactory($q, Service, ServiceHelper, TaskService, ResourceControlService, LogHelper) {
'use strict';
var service = {};
angular.module('portainer.docker')
.factory('ServiceService', ['$q', 'Service', 'ServiceHelper', 'TaskService', 'ResourceControlService', 'LogHelper',
function ServiceServiceFactory($q, Service, ServiceHelper, TaskService, ResourceControlService, LogHelper) {
'use strict';
var service = {};
service.services = function (filters) {
var deferred = $q.defer();
service.services = function(filters) {
var deferred = $q.defer();
Service.query({ filters: filters ? filters : {} })
.$promise.then(function success(data) {
var services = data.map(function (item) {
return new ServiceViewModel(item);
});
deferred.resolve(services);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve services', err: err });
});
Service.query({ filters: filters ? filters : {} }).$promise
.then(function success(data) {
var services = data.map(function (item) {
return new ServiceViewModel(item);
});
deferred.resolve(services);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve services', err: err });
});
return deferred.promise;
};
service.service = function(id) {
var deferred = $q.defer();
Service.get({ id: id }).$promise
.then(function success(data) {
var service = new ServiceViewModel(data);
deferred.resolve(service);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve service details', err: err });
});
return deferred.promise;
};
service.remove = function(service) {
var deferred = $q.defer();
Service.remove({id: service.Id}).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove service', err: err });
});
return deferred.promise;
};
service.update = function(serv, config, rollback) {
return service.service(serv.Id).then((data) => {
const params = {
id: serv.Id,
version: data.Version
};
if (rollback) {
params.rollback = rollback
}
return Service.update(params, config).$promise;
});
};
service.logs = function(id, stdout, stderr, timestamps, since, tail) {
var deferred = $q.defer();
var parameters = {
id: id,
stdout: stdout || 0,
stderr: stderr || 0,
timestamps: timestamps || 0,
since: since || 0,
tail: tail || 'all'
return deferred.promise;
};
Service.logs(parameters).$promise
.then(function success(data) {
var logs = LogHelper.formatLogs(data.logs, true);
deferred.resolve(logs);
})
.catch(function error(err) {
deferred.reject(err);
});
service.service = function (id) {
var deferred = $q.defer();
return deferred.promise;
};
Service.get({ id: id })
.$promise.then(function success(data) {
var service = new ServiceViewModel(data);
deferred.resolve(service);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve service details', err: err });
});
return service;
}]);
return deferred.promise;
};
service.remove = function (service) {
var deferred = $q.defer();
Service.remove({ id: service.Id })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove service', err: err });
});
return deferred.promise;
};
service.update = function (serv, config, rollback) {
return service.service(serv.Id).then((data) => {
const params = {
id: serv.Id,
version: data.Version,
};
if (rollback) {
params.rollback = rollback;
}
return Service.update(params, config).$promise;
});
};
service.logs = function (id, stdout, stderr, timestamps, since, tail) {
var deferred = $q.defer();
var parameters = {
id: id,
stdout: stdout || 0,
stderr: stderr || 0,
timestamps: timestamps || 0,
since: since || 0,
tail: tail || 'all',
};
Service.logs(parameters)
.$promise.then(function success(data) {
var logs = LogHelper.formatLogs(data.logs, true);
deferred.resolve(logs);
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
return service;
},
]);

View file

@ -1,24 +1,27 @@
import { SwarmViewModel } from '../models/swarm';
angular.module('portainer.docker')
.factory('SwarmService', ['$q', 'Swarm', function SwarmServiceFactory($q, Swarm) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('SwarmService', [
'$q',
'Swarm',
function SwarmServiceFactory($q, Swarm) {
'use strict';
var service = {};
service.swarm = function() {
var deferred = $q.defer();
service.swarm = function () {
var deferred = $q.defer();
Swarm.get().$promise
.then(function success(data) {
var swarm = new SwarmViewModel(data);
deferred.resolve(swarm);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve Swarm details', err: err });
});
Swarm.get()
.$promise.then(function success(data) {
var swarm = new SwarmViewModel(data);
deferred.resolve(swarm);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve Swarm details', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
return service;
}]);
return service;
},
]);

View file

@ -1,55 +1,59 @@
import {EventViewModel} from '../models/event';
import { EventViewModel } from '../models/event';
angular.module('portainer.docker')
.factory('SystemService', ['$q', 'System', 'SystemEndpoint', function SystemServiceFactory($q, System, SystemEndpoint) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('SystemService', [
'$q',
'System',
'SystemEndpoint',
function SystemServiceFactory($q, System, SystemEndpoint) {
'use strict';
var service = {};
service.plugins = function() {
var deferred = $q.defer();
System.info({}).$promise
.then(function success(data) {
var plugins = data.Plugins;
deferred.resolve(plugins);
})
.catch(function error(err) {
deferred.reject({msg: 'Unable to retrieve plugins information from system', err: err});
});
return deferred.promise;
};
service.plugins = function () {
var deferred = $q.defer();
System.info({})
.$promise.then(function success(data) {
var plugins = data.Plugins;
deferred.resolve(plugins);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve plugins information from system', err: err });
});
return deferred.promise;
};
service.info = function() {
return System.info({}).$promise;
};
service.info = function () {
return System.info({}).$promise;
};
service.ping = function(endpointId) {
return SystemEndpoint.ping({endpointId: endpointId}).$promise;
};
service.ping = function (endpointId) {
return SystemEndpoint.ping({ endpointId: endpointId }).$promise;
};
service.version = function() {
return System.version({}).$promise;
};
service.version = function () {
return System.version({}).$promise;
};
service.events = function(from, to) {
var deferred = $q.defer();
service.events = function (from, to) {
var deferred = $q.defer();
System.events({since: from, until: to}).$promise
.then(function success(data) {
var events = data.map(function (item) {
return new EventViewModel(item);
});
deferred.resolve(events);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve engine events', err: err });
});
System.events({ since: from, until: to })
.$promise.then(function success(data) {
var events = data.map(function (item) {
return new EventViewModel(item);
});
deferred.resolve(events);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve engine events', err: err });
});
return deferred.promise;
};
return deferred.promise;
};
service.dataUsage = function () {
return System.dataUsage().$promise;
};
service.dataUsage = function () {
return System.dataUsage().$promise;
};
return service;
}]);
return service;
},
]);

View file

@ -1,66 +1,69 @@
import { TaskViewModel } from '../models/task';
angular.module('portainer.docker')
.factory('TaskService', ['$q', 'Task', 'LogHelper',
function TaskServiceFactory($q, Task, LogHelper) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('TaskService', [
'$q',
'Task',
'LogHelper',
function TaskServiceFactory($q, Task, LogHelper) {
'use strict';
var service = {};
service.task = function(id) {
var deferred = $q.defer();
service.task = function (id) {
var deferred = $q.defer();
Task.get({ id: id }).$promise
.then(function success(data) {
var task = new TaskViewModel(data);
deferred.resolve(task);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve task details', err: err });
});
Task.get({ id: id })
.$promise.then(function success(data) {
var task = new TaskViewModel(data);
deferred.resolve(task);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve task details', err: err });
});
return deferred.promise;
};
service.tasks = function(filters) {
var deferred = $q.defer();
Task.query({ filters: filters ? filters : {} }).$promise
.then(function success(data) {
var tasks = data.map(function (item) {
return new TaskViewModel(item);
});
deferred.resolve(tasks);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve tasks', err: err });
});
return deferred.promise;
};
service.logs = function(id, stdout, stderr, timestamps, since, tail) {
var deferred = $q.defer();
var parameters = {
id: id,
stdout: stdout || 0,
stderr: stderr || 0,
timestamps: timestamps || 0,
since: since || 0,
tail: tail || 'all'
return deferred.promise;
};
Task.logs(parameters).$promise
.then(function success(data) {
var logs = LogHelper.formatLogs(data.logs, true);
deferred.resolve(logs);
})
.catch(function error(err) {
deferred.reject(err);
});
service.tasks = function (filters) {
var deferred = $q.defer();
return deferred.promise;
};
Task.query({ filters: filters ? filters : {} })
.$promise.then(function success(data) {
var tasks = data.map(function (item) {
return new TaskViewModel(item);
});
deferred.resolve(tasks);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve tasks', err: err });
});
return service;
}]);
return deferred.promise;
};
service.logs = function (id, stdout, stderr, timestamps, since, tail) {
var deferred = $q.defer();
var parameters = {
id: id,
stdout: stdout || 0,
stderr: stderr || 0,
timestamps: timestamps || 0,
since: since || 0,
tail: tail || 'all',
};
Task.logs(parameters)
.$promise.then(function success(data) {
var logs = LogHelper.formatLogs(data.logs, true);
deferred.resolve(logs);
})
.catch(function error(err) {
deferred.reject(err);
});
return deferred.promise;
};
return service;
},
]);

View file

@ -1,101 +1,105 @@
import { VolumeViewModel } from '../models/volume';
angular.module('portainer.docker')
.factory('VolumeService', ['$q', 'Volume', 'VolumeHelper', function VolumeServiceFactory($q, Volume, VolumeHelper) {
'use strict';
var service = {};
angular.module('portainer.docker').factory('VolumeService', [
'$q',
'Volume',
'VolumeHelper',
function VolumeServiceFactory($q, Volume, VolumeHelper) {
'use strict';
var service = {};
service.volumes = function(params) {
var deferred = $q.defer();
Volume.query(params).$promise
.then(function success(data) {
var volumes = data.Volumes || [];
volumes = volumes.map(function (item) {
return new VolumeViewModel(item);
});
deferred.resolve(volumes);
})
.catch(function error(err) {
deferred.reject({msg: 'Unable to retrieve volumes', err: err});
});
return deferred.promise;
};
service.volume = function(id) {
var deferred = $q.defer();
Volume.get({id: id}).$promise
.then(function success(data) {
var volume = new VolumeViewModel(data);
deferred.resolve(volume);
})
.catch(function error(err) {
deferred.reject({msg: 'Unable to retrieve volume details', err: err});
});
return deferred.promise;
};
service.getVolumes = function() {
return Volume.query({}).$promise;
};
service.remove = function(volume) {
var deferred = $q.defer();
Volume.remove({id: volume.Id}).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove volume', err: err });
});
return deferred.promise;
};
service.createVolumeConfiguration = function(name, driver, driverOptions) {
var volumeConfiguration = {
Name: name,
Driver: driver,
DriverOpts: VolumeHelper.createDriverOptions(driverOptions)
service.volumes = function (params) {
var deferred = $q.defer();
Volume.query(params)
.$promise.then(function success(data) {
var volumes = data.Volumes || [];
volumes = volumes.map(function (item) {
return new VolumeViewModel(item);
});
deferred.resolve(volumes);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve volumes', err: err });
});
return deferred.promise;
};
return volumeConfiguration;
};
service.createVolume = function(volumeConfiguration) {
var deferred = $q.defer();
Volume.create(volumeConfiguration).$promise
.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
var volume = new VolumeViewModel(data);
deferred.resolve(volume);
service.volume = function (id) {
var deferred = $q.defer();
Volume.get({ id: id })
.$promise.then(function success(data) {
var volume = new VolumeViewModel(data);
deferred.resolve(volume);
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve volume details', err: err });
});
return deferred.promise;
};
service.getVolumes = function () {
return Volume.query({}).$promise;
};
service.remove = function (volume) {
var deferred = $q.defer();
Volume.remove({ id: volume.Id })
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message, err: data.message });
} else {
deferred.resolve();
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to remove volume', err: err });
});
return deferred.promise;
};
service.createVolumeConfiguration = function (name, driver, driverOptions) {
var volumeConfiguration = {
Name: name,
Driver: driver,
DriverOpts: VolumeHelper.createDriverOptions(driverOptions),
};
return volumeConfiguration;
};
service.createVolume = function (volumeConfiguration) {
var deferred = $q.defer();
Volume.create(volumeConfiguration)
.$promise.then(function success(data) {
if (data.message) {
deferred.reject({ msg: data.message });
} else {
var volume = new VolumeViewModel(data);
deferred.resolve(volume);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to create volume', err: err });
});
return deferred.promise;
};
service.createVolumes = function (volumeConfigurations) {
var createVolumeQueries = volumeConfigurations.map(function (volumeConfiguration) {
return service.createVolume(volumeConfiguration);
});
return $q.all(createVolumeQueries);
};
service.createXAutoGeneratedLocalVolumes = function (x) {
var createVolumeQueries = [];
for (var i = 0; i < x; i++) {
createVolumeQueries.push(service.createVolume({ Driver: 'local' }));
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to create volume', err: err });
});
return deferred.promise;
};
return $q.all(createVolumeQueries);
};
service.createVolumes = function(volumeConfigurations) {
var createVolumeQueries = volumeConfigurations.map(function(volumeConfiguration) {
return service.createVolume(volumeConfiguration);
});
return $q.all(createVolumeQueries);
};
service.createXAutoGeneratedLocalVolumes = function (x) {
var createVolumeQueries = [];
for (var i = 0; i < x; i++) {
createVolumeQueries.push(service.createVolume({ Driver: 'local' }));
}
return $q.all(createVolumeQueries);
};
return service;
}]);
return service;
},
]);