portainer/app/docker/services/imageService.js

204 lines
6.2 KiB
JavaScript

import _ from 'lodash';
import { getUniqueTagListFromImages } from '@/react/docker/images/utils';
import { ImageViewModel } from '../models/image';
import { ImageDetailsViewModel } from '../models/imageDetails';
import { ImageLayerViewModel } from '../models/imageLayer';
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 = {};
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;
const containerByImageId = _.groupBy(containers, 'ImageID');
var images = data.images.map(function (item) {
item.Used = !!containerByImageId[item.Id] && containerByImageId[item.Id].length > 0;
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--;
});
deferred.resolve(layers);
}
})
.catch(function error(err) {
deferred.reject({ msg: 'Unable to retrieve image details', err: err });
});
return deferred.promise;
};
service.pushImage = pushImage;
/**
*
* @param {PorImageRegistryModel} registryModel
*/
function pushImage(registryModel) {
var deferred = $q.defer();
var authenticationDetails = registryModel.Registry.Authentication ? RegistryService.encodedCredentials(registryModel.Registry) : '';
HttpRequestHelper.setRegistryAuthenticationHeader(authenticationDetails);
const imageConfiguration = ImageHelper.createImageConfigForContainer(registryModel);
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;
}
/**
* PULL IMAGE
*/
function pullImageAndIgnoreErrors(imageConfiguration) {
var deferred = $q.defer();
Image.create({}, imageConfiguration)
.$promise.catch(() => {
// left empty to ignore errors
})
.finally(function final() {
deferred.resolve();
});
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].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 = getUniqueTagListFromImages;
return service;
},
]);