docker-storage-gc 4.0.0 → 4.0.1

package/lib/index.ts

@@ -102,42 +102,33 @@ export default class DockerGC {
 		this.host = hostname;
 	}
 
-	public setDocker(hostObj: Docker.DockerOptions): Promise<void> {
+	public async setDocker(hostObj: Docker.DockerOptions): Promise<void> {
 		this.currentMtimes = {};
-		hostObj = _.defaults({ Promise: Bluebird }, hostObj);
 		this.dockerProgress = new DockerProgress({
 			docker: new Docker(hostObj),
 		});
-		return getDocker(hostObj)
-			.then((docker) => {
-				// Docker info can take a while so do it here,
-				// and don't wait on the results
-				this.docker = docker;
-				return (this.baseImagePromise = this.getDaemonArchitecture().then(
-					function (arch) {
-						switch (arch) {
-							case 'arm':
-								return 'arm32v6/alpine:3.6';
-							case 'arm64':
-								return 'arm64v8/alpine:3.6';
-							case 'amd64':
-								return 'alpine:3.6';
-							default:
-								throw new Error('Could not detect architecture of remote host');
-						}
-					},
-				));
-			})
-			.then(() => {
-				// noop
-			});
+		const docker = getDocker(hostObj);
+		// Docker info can take a while so do it here,
+		// and don't wait on the results
+		this.docker = docker;
+		await (this.baseImagePromise = this.getDaemonArchitecture().then((arch) => {
+			switch (arch) {
+				case 'arm':
+					return 'arm32v6/alpine:3.6';
+				case 'arm64':
+					return 'arm64v8/alpine:3.6';
+				case 'amd64':
+					return 'alpine:3.6';
+				default:
+					throw new Error('Could not detect architecture of remote host');
+			}
+		}));
 	}
 
-	public setupMtimeStream(): Promise<void> {
-		return dockerMtimeStream(this.docker).then((stream) => {
-			stream.on('data', (layerMtimes: LayerMtimes) => {
-				this.currentMtimes = layerMtimes;
-			});
+	public async setupMtimeStream(): Promise<void> {
+		const stream = await dockerMtimeStream(this.docker);
+		stream.on('data', (layerMtimes: LayerMtimes) => {
+			this.currentMtimes = layerMtimes;
 		});
 	}
 
@@ -165,60 +156,56 @@ export default class DockerGC {
 		removalType: 'tag' | 'digest' | 'id',
 	): Promise<void> | undefined {
 		if (attributes.length > 0) {
-			return Bluebird.each(attributes, (attribute) => {
-				console.log(
-					`[GC (${this.host}] Removing image : ${attribute} (id: ${image.id})`,
-				);
-				return this.docker
-					.getImage(attribute)
-					.remove({ noprune: true })
-					.then(() => {
-						this.metrics.emit('imageRemoved', removalType);
-					});
-			}).then(() => {
-				// noop
-			});
+			return (async () => {
+				for (const attribute of attributes) {
+					console.log(
+						`[GC (${this.host}] Removing image : ${attribute} (id: ${image.id})`,
+					);
+					await this.docker.getImage(attribute).remove({ noprune: true });
+					this.metrics.emit('imageRemoved', removalType);
+				}
+			})();
 		}
 	}
 
-	public garbageCollect(
+	public async garbageCollect(
 		reclaimSpace: number,
 		attemptAll = false,
 	): Promise<void> {
 		let err: any;
 		const startTime = process.hrtime();
 		this.metrics.emit('spaceReclaimed', reclaimSpace);
-		return dockerImageTree(this.docker, this.currentMtimes)
-			.then((tree) => {
-				return getImagesToRemove(tree, reclaimSpace, this.metrics);
-			})
-			.each((image) => {
-				return this.removeImage(image).catch((e) => {
-					this.metrics.emit('imageRemovalError', e.statusCode);
-					console.log(`[GC ${this.host}]: Failed to remove image: `, image);
-					console.log(e);
-					if (attemptAll) {
-						err ??= e;
-						return;
-					} else {
-						recordGcRunTime(startTime, this.metrics);
-						throw e;
-					}
-				});
-			})
-			.then(() => {
-				recordGcRunTime(startTime, this.metrics);
-				if (err != null) {
-					throw err;
+
+		const tree = await dockerImageTree(this.docker, this.currentMtimes);
+		const images = await getImagesToRemove(tree, reclaimSpace, this.metrics);
+		for (const image of images) {
+			try {
+				await this.removeImage(image);
+			} catch (e: any) {
+				this.metrics.emit('imageRemovalError', e.statusCode);
+				console.log(`[GC ${this.host}]: Failed to remove image: `, image);
+				console.log(e);
+				if (attemptAll) {
+					err ??= e;
+				} else {
+					recordGcRunTime(startTime, this.metrics);
+					throw e;
 				}
-			});
+			}
+		}
+		recordGcRunTime(startTime, this.metrics);
+		if (err != null) {
+			throw err;
+		}
 	}
 
 	private getOutput(image: string, command: string[]): Promise<string> {
-		return Bluebird.using(this.runDisposer(image, command), (container) =>
-			container
-				.logs({ stdout: true, follow: true })
-				.then((logs) => streamToString(logs)),
+		return Bluebird.using(
+			this.runDisposer(image, command),
+			async (container) => {
+				const logs = await container.logs({ stdout: true, follow: true });
+				return await streamToString(logs);
+			},
 		);
 	}
 
@@ -235,38 +222,43 @@ export default class DockerGC {
 			);
 		return Bluebird.resolve(
 			containerPromise.then(([, container]) => container),
-		).disposer((container) => container.wait().then(() => container.remove()));
+		).disposer(async (container) => {
+			await container.wait();
+			await container.remove();
+		});
 	}
 
-	public getDaemonFreeSpace(): Promise<{
+	public async getDaemonFreeSpace(): Promise<{
 		used: number;
 		total: number;
 		free: number;
 	}> {
-		return Bluebird.resolve(this.baseImagePromise)
-			.tap((baseImage) => {
-				// Ensure the image is available (if it is this is essentially a no-op)
-				return this.dockerProgress.pull(baseImage, _.noop);
-			})
-			.then((baseImage) => {
-				return this.getOutput(baseImage, ['/bin/df', '-B', '1', '/']);
-			})
-			.then(function (spaceStr) {
-				// First split the lines, as we're only interested in the second one
-				const lines = spaceStr.trim().split(/\r?\n/);
-				if (lines.length !== 2) {
-					throw new Error('Coult not parse df output');
-				}
+		const baseImage = await this.baseImagePromise;
+
+		// Ensure the image is available (if it is this is essentially a no-op)
+		await this.dockerProgress.pull(baseImage, _.noop);
+
+		const spaceStr = await this.getOutput(baseImage, [
+			'/bin/df',
+			'-B',
+			'1',
+			'/',
+		]);
+		// First split the lines, as we're only interested in the second one
+		const lines = spaceStr.trim().split(/\r?\n/);
+		if (lines.length !== 2) {
+			throw new Error('Coult not parse df output');
+		}
 
-				const parts = lines[1].split(/\s+/);
-				const total = parseInt(parts[1], 10);
-				const used = parseInt(parts[2], 10);
-				const free = parseInt(parts[3], 10);
-				return { used, total, free };
-			});
+		const parts = lines[1].split(/\s+/);
+		const total = parseInt(parts[1], 10);
+		const used = parseInt(parts[2], 10);
+		const free = parseInt(parts[3], 10);
+		return { used, total, free };
 	}
 
-	private getDaemonArchitecture() {
-		return this.docker.version().then(({ Arch }) => Arch);
+	private async getDaemonArchitecture() {
+		const { Arch } = await this.docker.version();
+		return Arch;
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docker-storage-gc",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "main": "build/index.js",
   "scripts": {
     "lint": "balena-lint -t tsconfig.dev.json -e ts -e js lib test tools",
@@ -39,6 +39,6 @@
     "typescript": "^5.3.2"
   },
   "versionist": {
-    "publishedAt": "2023-12-04T17:24:21.020Z"
+    "publishedAt": "2023-12-05T22:24:21.230Z"
   }
 }

package/test/docker-event-stream.ts

@@ -11,36 +11,32 @@ describe('parseEventStream', function () {
 		// TODO
 	});
 
-	it('should return updated mtimes', () =>
-		getDocker({})
-			.then((docker) => parseEventStream(docker))
-			.then(
-				(streamParser) =>
-					new Promise<LayerMtimes>(function (resolve, reject) {
-						let mtimes: LayerMtimes;
+	it('should return updated mtimes', async () => {
+		const docker = await getDocker({});
+		const streamParser = await parseEventStream(docker);
+		const data = await new Promise<LayerMtimes>(function (resolve, reject) {
+			let mtimes: LayerMtimes;
 
-						return fs
-							.createReadStream(__dirname + '/fixtures/docker-events.json')
-							.pipe(streamParser)
-							.on('error', reject)
-							.pipe(es.mapSync((data: LayerMtimes) => (mtimes = data)))
-							.on('end', () => resolve(mtimes))
-							.on('error', reject);
-					}),
+			return fs
+				.createReadStream(__dirname + '/fixtures/docker-events.json')
+				.pipe(streamParser)
+				.on('error', reject)
+				.pipe(es.mapSync(($data: LayerMtimes) => (mtimes = $data)))
+				.on('end', () => resolve(mtimes))
+				.on('error', reject);
+		});
+		expect(data)
+			.to.have.property('busybox:latest')
+			.that.equals(1448576072937294800);
+		expect(data)
+			.to.have.property(
+				'sha256:6d41a4a0bf8168363e29da8a5ecbf3cd6c37e3f5a043decd5e7da6e427ba869c',
 			)
-			.then(function (data) {
-				expect(data)
-					.to.have.property('busybox:latest')
-					.that.equals(1448576072937294800);
-				expect(data)
-					.to.have.property(
-						'sha256:6d41a4a0bf8168363e29da8a5ecbf3cd6c37e3f5a043decd5e7da6e427ba869c',
-					)
-					.that.equals(1448576073085559800);
-				expect(data)
-					.to.have.property(
-						'sha256:9a61b6b1315e6b457c31a03346ab94486a2f5397f4a82219bee01eead1c34c2e',
-					)
-					.that.equals(1448576073203895800);
-			}));
+			.that.equals(1448576073085559800);
+		expect(data)
+			.to.have.property(
+				'sha256:9a61b6b1315e6b457c31a03346ab94486a2f5397f4a82219bee01eead1c34c2e',
+			)
+			.that.equals(1448576073203895800);
+	});
 });

package/test/docker-image-tree.ts

@@ -7,22 +7,20 @@ import { LayerMtimes, parseEventStream } from '../build/docker-event-stream';
 import { createTree } from '../build/docker-image-tree';
 import { getDocker } from '../build/docker';
 
-const getLayerMtimes = () =>
-	getDocker({})
-		.then((docker) => parseEventStream(docker))
-		.then(
-			(streamParser) =>
-				new Promise<LayerMtimes>(function (resolve, reject) {
-					let mtimes: LayerMtimes;
-					return fs
-						.createReadStream(__dirname + '/fixtures/docker-events.json')
-						.pipe(streamParser)
-						.on('error', reject)
-						.pipe(es.mapSync((data: LayerMtimes) => (mtimes = data)))
-						.on('end', () => resolve(mtimes))
-						.on('error', reject);
-				}),
-		);
+const getLayerMtimes = async () => {
+	const docker = await getDocker({});
+	const streamParser = await parseEventStream(docker);
+	return await new Promise<LayerMtimes>(function (resolve, reject) {
+		let mtimes: LayerMtimes;
+		return fs
+			.createReadStream(__dirname + '/fixtures/docker-events.json')
+			.pipe(streamParser)
+			.on('error', reject)
+			.pipe(es.mapSync((data: LayerMtimes) => (mtimes = data)))
+			.on('end', () => resolve(mtimes))
+			.on('error', reject);
+	});
+};
 
 describe('createTree', function () {
 	it.skip('should work with empty input', function () {
@@ -40,98 +38,97 @@ describe('createTree', function () {
 				assert: { type: 'json' },
 			})
 		).default as ContainerInfo[];
-		return getLayerMtimes().then(function (mtimes) {
-			tk.freeze(Date.UTC(2016, 0, 1));
-			const tree = createTree(images, containers, mtimes);
-			tk.reset();
-			const output = {
-				id: '0000000000000000000000000000000000000000000000000000000000000000',
-				size: 0,
-				repoTags: [],
-				repoDigests: [],
-				mtime: 1451606400000000000,
-				isUsedByAContainer: false,
-				children: {
-					'sha256:6d15899cef812e2876b9d5d43d4cd863eda7b278f7b52d00975f6a9a8e817c74':
-						{
-							id: 'sha256:6d15899cef812e2876b9d5d43d4cd863eda7b278f7b52d00975f6a9a8e817c74',
-							size: 125151141,
-							repoTags: [],
-							repoDigests: [],
-							mtime: 1451606400000000000,
-							isUsedByAContainer: false,
-							children: {
-								'sha256:e53bd4df04f86919156c4510cdc6e6c9491ec8ec226381d36aca573b46bbbbbc':
-									{
-										id: 'sha256:e53bd4df04f86919156c4510cdc6e6c9491ec8ec226381d36aca573b46bbbbbc',
-										size: 0,
-										repoTags: ['project1'],
-										repoDigests: [],
-										mtime: 1451606400000000000,
-										isUsedByAContainer: false,
-										children: {
-											'sha256:6d41a4a0bf8168363e29da8a5ecbf3cd6c37e3f5a043decd5e7da6e427ba869c':
-												{
-													id: 'sha256:6d41a4a0bf8168363e29da8a5ecbf3cd6c37e3f5a043decd5e7da6e427ba869c',
-													size: 330389,
-													repoTags: ['project2'],
-													repoDigests: [],
-													// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-													mtime: 1448576073085559863,
-													isUsedByAContainer: false,
-													children: {
-														'sha256:80dc79d29cd8618e678da508fc32f7289e6f72defb534f3f287731b1f8b355ea':
-															{
-																id: 'sha256:80dc79d29cd8618e678da508fc32f7289e6f72defb534f3f287731b1f8b355ea',
-																size: 98872,
-																repoTags: [],
-																repoDigests: [],
-																mtime: 1451606400000000000,
-																isUsedByAContainer: false,
-																children: {},
-															},
-													},
+		const mtimes = await getLayerMtimes();
+		tk.freeze(Date.UTC(2016, 0, 1));
+		const tree = createTree(images, containers, mtimes);
+		tk.reset();
+		const output = {
+			id: '0000000000000000000000000000000000000000000000000000000000000000',
+			size: 0,
+			repoTags: [],
+			repoDigests: [],
+			mtime: 1451606400000000000,
+			isUsedByAContainer: false,
+			children: {
+				'sha256:6d15899cef812e2876b9d5d43d4cd863eda7b278f7b52d00975f6a9a8e817c74':
+					{
+						id: 'sha256:6d15899cef812e2876b9d5d43d4cd863eda7b278f7b52d00975f6a9a8e817c74',
+						size: 125151141,
+						repoTags: [],
+						repoDigests: [],
+						mtime: 1451606400000000000,
+						isUsedByAContainer: false,
+						children: {
+							'sha256:e53bd4df04f86919156c4510cdc6e6c9491ec8ec226381d36aca573b46bbbbbc':
+								{
+									id: 'sha256:e53bd4df04f86919156c4510cdc6e6c9491ec8ec226381d36aca573b46bbbbbc',
+									size: 0,
+									repoTags: ['project1'],
+									repoDigests: [],
+									mtime: 1451606400000000000,
+									isUsedByAContainer: false,
+									children: {
+										'sha256:6d41a4a0bf8168363e29da8a5ecbf3cd6c37e3f5a043decd5e7da6e427ba869c':
+											{
+												id: 'sha256:6d41a4a0bf8168363e29da8a5ecbf3cd6c37e3f5a043decd5e7da6e427ba869c',
+												size: 330389,
+												repoTags: ['project2'],
+												repoDigests: [],
+												// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+												mtime: 1448576073085559863,
+												isUsedByAContainer: false,
+												children: {
+													'sha256:80dc79d29cd8618e678da508fc32f7289e6f72defb534f3f287731b1f8b355ea':
+														{
+															id: 'sha256:80dc79d29cd8618e678da508fc32f7289e6f72defb534f3f287731b1f8b355ea',
+															size: 98872,
+															repoTags: [],
+															repoDigests: [],
+															mtime: 1451606400000000000,
+															isUsedByAContainer: false,
+															children: {},
+														},
 												},
-										},
-									},
-							},
-						},
-					'sha256:902b87aaaec929e80541486828959f14fa061f529ad7f37ab300d4ef9f3a0dbf':
-						{
-							id: 'sha256:902b87aaaec929e80541486828959f14fa061f529ad7f37ab300d4ef9f3a0dbf',
-							size: 125151141,
-							repoTags: [],
-							repoDigests: [],
-							mtime: 1451606400000000000,
-							isUsedByAContainer: false,
-							children: {
-								'sha256:9a61b6b1315e6b457c31a03346ab94486a2f5397f4a82219bee01eead1c34c2e':
-									{
-										id: 'sha256:9a61b6b1315e6b457c31a03346ab94486a2f5397f4a82219bee01eead1c34c2e',
-										size: 0,
-										repoTags: ['resin/project3'],
-										repoDigests: [],
-										mtime: 1448576073203895800,
-										isUsedByAContainer: false,
-										children: {},
+											},
 									},
-							},
+								},
 						},
-					'sha256:5b0d59026729b68570d99bc4f3f7c31a2e4f2a5736435641565d93e7c25bd2c3':
-						{
-							id: 'sha256:5b0d59026729b68570d99bc4f3f7c31a2e4f2a5736435641565d93e7c25bd2c3',
-							size: 125151141,
-							repoTags: ['busybox:latest'],
-							repoDigests: [
-								'sha256:a8cf7ff6367c2afa2a90acd081b484cbded349a7076e7bdf37a05279f276bc12',
-							],
-							mtime: 1448576072937294800,
-							isUsedByAContainer: true,
-							children: {},
+					},
+				'sha256:902b87aaaec929e80541486828959f14fa061f529ad7f37ab300d4ef9f3a0dbf':
+					{
+						id: 'sha256:902b87aaaec929e80541486828959f14fa061f529ad7f37ab300d4ef9f3a0dbf',
+						size: 125151141,
+						repoTags: [],
+						repoDigests: [],
+						mtime: 1451606400000000000,
+						isUsedByAContainer: false,
+						children: {
+							'sha256:9a61b6b1315e6b457c31a03346ab94486a2f5397f4a82219bee01eead1c34c2e':
+								{
+									id: 'sha256:9a61b6b1315e6b457c31a03346ab94486a2f5397f4a82219bee01eead1c34c2e',
+									size: 0,
+									repoTags: ['resin/project3'],
+									repoDigests: [],
+									mtime: 1448576073203895800,
+									isUsedByAContainer: false,
+									children: {},
+								},
 						},
-				},
-			};
-			expect(tree).to.deep.equal(output);
-		});
+					},
+				'sha256:5b0d59026729b68570d99bc4f3f7c31a2e4f2a5736435641565d93e7c25bd2c3':
+					{
+						id: 'sha256:5b0d59026729b68570d99bc4f3f7c31a2e4f2a5736435641565d93e7c25bd2c3',
+						size: 125151141,
+						repoTags: ['busybox:latest'],
+						repoDigests: [
+							'sha256:a8cf7ff6367c2afa2a90acd081b484cbded349a7076e7bdf37a05279f276bc12',
+						],
+						mtime: 1448576072937294800,
+						isUsedByAContainer: true,
+						children: {},
+					},
+			},
+		};
+		expect(tree).to.deep.equal(output);
 	});
 });