@apiclient.xyz/docker
Version:
Provides easy communication with Docker remote API from Node.js, with TypeScript support.
258 lines • 20.8 kB
JavaScript
import * as plugins from './plugins.js';
import * as interfaces from './interfaces/index.js';
import { DockerHost } from './classes.host.js';
import { DockerResource } from './classes.base.js';
import { logger } from './logger.js';
/**
* represents a docker image on the remote docker host
*/
export class DockerImage extends DockerResource {
// STATIC (Internal - prefixed with _ to indicate internal use)
/**
* Internal: Get all images
* Public API: Use dockerHost.listImages() instead
*/
static async _list(dockerHost) {
const images = [];
const response = await dockerHost.request('GET', '/images/json');
for (const imageObject of response.body) {
images.push(new DockerImage(dockerHost, imageObject));
}
return images;
}
/**
* Internal: Get image by name
* Public API: Use dockerHost.getImageByName(name) instead
*/
static async _fromName(dockerHost, imageNameArg) {
const images = await this._list(dockerHost);
const result = images.find((image) => {
if (image.RepoTags) {
return image.RepoTags.includes(imageNameArg);
}
else {
return false;
}
});
return result;
}
/**
* Internal: Create image from registry
* Public API: Use dockerHost.createImageFromRegistry(descriptor) instead
*/
static async _createFromRegistry(dockerHostArg, optionsArg) {
// lets create a sanatized imageUrlObject
const imageUrlObject = {
imageUrl: optionsArg.creationObject.imageUrl,
imageTag: optionsArg.creationObject.imageTag ?? '',
imageOriginTag: '',
};
if (imageUrlObject.imageUrl.includes(':')) {
const imageUrl = imageUrlObject.imageUrl.split(':')[0];
const imageTag = imageUrlObject.imageUrl.split(':')[1];
if (imageUrlObject.imageTag) {
throw new Error(`imageUrl ${imageUrlObject.imageUrl} can't be tagged with ${imageUrlObject.imageTag} because it is already tagged with ${imageTag}`);
}
else {
imageUrlObject.imageUrl = imageUrl;
imageUrlObject.imageTag = imageTag;
}
}
else if (!imageUrlObject.imageTag) {
imageUrlObject.imageTag = 'latest';
}
imageUrlObject.imageOriginTag = `${imageUrlObject.imageUrl}:${imageUrlObject.imageTag}`;
// lets actually create the image
const response = await dockerHostArg.request('POST', `/images/create?fromImage=${encodeURIComponent(imageUrlObject.imageUrl)}&tag=${encodeURIComponent(imageUrlObject.imageTag)}`);
if (response.statusCode < 300) {
logger.log('info', `Successfully pulled image ${imageUrlObject.imageUrl} from the registry`);
const image = await DockerImage._fromName(dockerHostArg, imageUrlObject.imageOriginTag);
if (!image) {
throw new Error(`Image ${imageUrlObject.imageOriginTag} not found after pull`);
}
return image;
}
else {
// Pull failed — check if the image already exists locally
const existingImage = await DockerImage._fromName(dockerHostArg, imageUrlObject.imageOriginTag);
if (existingImage) {
logger.log('warn', `Pull failed for ${imageUrlObject.imageUrl}, using locally cached image`);
return existingImage;
}
throw new Error(`Failed to pull image ${imageUrlObject.imageOriginTag} and no local copy exists`);
}
}
/**
* Internal: Create image from tar stream
* Public API: Use dockerHost.createImageFromTarStream(stream, descriptor) instead
*/
static async _createFromTarStream(dockerHostArg, optionsArg) {
// Start the request for importing an image
const response = await dockerHostArg.requestStreaming('POST', '/images/load', optionsArg.tarStream);
// requestStreaming now returns Node.js stream
const nodeStream = response;
/**
* Docker typically returns lines like:
* {"stream":"Loaded image: myrepo/myimage:latest"}
*
* So we will collect those lines and parse out the final image name.
*/
let rawOutput = '';
nodeStream.on('data', (chunk) => {
rawOutput += chunk.toString();
});
// Wrap the end event in a Promise for easier async/await usage
await new Promise((resolve, reject) => {
nodeStream.on('end', () => {
resolve();
});
nodeStream.on('error', (err) => {
reject(err);
});
});
// Attempt to parse each line to find something like "Loaded image: ..."
let loadedImageTag;
const lines = rawOutput.trim().split('\n').filter(Boolean);
for (const line of lines) {
try {
const jsonLine = JSON.parse(line);
if (jsonLine.stream &&
(jsonLine.stream.startsWith('Loaded image:') ||
jsonLine.stream.startsWith('Loaded image ID:'))) {
// Examples:
// "Loaded image: your-image:latest"
// "Loaded image ID: sha256:...."
loadedImageTag = jsonLine.stream
.replace('Loaded image: ', '')
.replace('Loaded image ID: ', '')
.trim();
}
}
catch {
// not valid JSON, ignore
}
}
if (!loadedImageTag) {
throw new Error(`Could not parse the loaded image info from Docker response.\nResponse was:\n${rawOutput}`);
}
// Now try to look up that image by the "loadedImageTag".
// Depending on Docker's response, it might be something like:
// "myrepo/myimage:latest" OR "sha256:someHash..."
// If Docker gave you an ID (e.g. "sha256:..."), you may need a separate
// DockerImage.getImageById method; or if you prefer, you can treat it as a name.
const newlyImportedImage = await DockerImage._fromName(dockerHostArg, loadedImageTag);
if (!newlyImportedImage) {
throw new Error(`Image load succeeded, but no local reference found for "${loadedImageTag}".`);
}
logger.log('info', `Successfully imported image "${loadedImageTag}".`);
return newlyImportedImage;
}
static async tagImageByIdOrName(dockerHost, idOrNameArg, newTagArg) {
const response = await dockerHost.request('POST', `/images/${encodeURIComponent(idOrNameArg)}/${encodeURIComponent(newTagArg)}`);
}
/**
* Internal: Build image from Dockerfile
* Public API: Use dockerHost.buildImage(tag) instead
*/
static async _build(dockerHostArg, dockerImageTag) {
// TODO: implement building an image
}
constructor(dockerHostArg, dockerImageObjectArg) {
super(dockerHostArg);
Object.keys(dockerImageObjectArg).forEach((keyArg) => {
this[keyArg] = dockerImageObjectArg[keyArg];
});
}
// INSTANCE METHODS
/**
* Refreshes this image's state from the Docker daemon
*/
async refresh() {
if (!this.RepoTags || this.RepoTags.length === 0) {
throw new Error('Cannot refresh image without RepoTags');
}
const updated = await DockerImage._fromName(this.dockerHost, this.RepoTags[0]);
if (updated) {
Object.assign(this, updated);
}
}
/**
* tag an image
* @param newTag
*/
async tagImage(newTag) {
throw new Error('.tagImage is not yet implemented');
}
/**
* pulls the latest version from the registry
*/
async pullLatestImageFromRegistry() {
const updatedImage = await DockerImage._createFromRegistry(this.dockerHost, {
creationObject: {
imageUrl: this.RepoTags[0],
},
});
Object.assign(this, updatedImage);
// TODO: Compare image digists before and after
return true;
}
/**
* Removes this image from the Docker daemon
*/
async remove(options) {
const queryParams = new URLSearchParams();
if (options?.force)
queryParams.append('force', '1');
if (options?.noprune)
queryParams.append('noprune', '1');
const queryString = queryParams.toString();
const response = await this.dockerHost.request('DELETE', `/images/${encodeURIComponent(this.Id)}${queryString ? '?' + queryString : ''}`);
if (response.statusCode >= 300) {
throw new Error(`Failed to remove image: ${response.statusCode}`);
}
}
// get stuff
async getVersion() {
if (this.Labels && this.Labels.version) {
return this.Labels.version;
}
else {
return '0.0.0';
}
}
/**
* exports an image to a tar ball
*/
async exportToTarStream() {
logger.log('info', `Exporting image ${this.RepoTags[0]} to tar stream.`);
const response = await this.dockerHost.requestStreaming('GET', `/images/${encodeURIComponent(this.RepoTags[0])}/get`);
// requestStreaming now returns Node.js stream
const nodeStream = response;
let counter = 0;
const webduplexStream = new plugins.smartstream.SmartDuplex({
writeFunction: async (chunk, tools) => {
if (counter % 1000 === 0)
console.log(`Got chunk: ${counter}`);
counter++;
return chunk;
},
});
nodeStream.on('data', (chunk) => {
if (!webduplexStream.write(chunk)) {
nodeStream.pause();
webduplexStream.once('drain', () => {
nodeStream.resume();
});
}
});
nodeStream.on('end', () => {
webduplexStream.end();
});
nodeStream.on('error', (error) => {
logger.log('error', `Error during image export: ${error.message}`);
webduplexStream.destroy(error);
});
return webduplexStream;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.image.js","sourceRoot":"","sources":["../ts/classes.image.ts"],"names":[],"mappings":"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"}