How to return value from executing a command from container?

[chill37]

I've used your example on running container exec.
https://github.com/apocas/dockerode/blob/v3.3.5/examples/exec_running_container.js

in the log, i can see the result of the execution, but i want to be able to use the result. But right now, it looks like it's just a log.

my code:

async a() {
    const docker = new Docker(networkConfig.ipfs);
    const dockerode = docker.getDockerode();
    const container = dockerode.getContainer('xxx');
    const id = await this.runExec(container);
    console.log("id"+id);
}

async runExec(container: any): Promise<any> {
        const options = {
            Cmd: ['ipfs', 'id'],
            AttachStdin: true,
            AttachStdout: true,
            AttachStderr: true
        };
        const attach_opts = {
            stream: true,
            stdin: true,
            stdout: true,
            stderr: true
        };
        try {
            const exec = await container.exec(options);
            const stream = await exec.start(attach_opts);
            const aa = await container.modem.demuxStream(stream, process.stdout, process.stderr);
            const data = await exec.inspect();
            console.log("data: "+data);
            return data;
        } catch (error) {
            console.error(error);
            throw error;
        }
    }

result is:

data:
{
  ID: '28468c484a1cb4d3bb20446d99ce8930f34b12fb0f18b31482c496d3d6b7c833',
  Running: true,
  ExitCode: null,
  ProcessConfig: {
    tty: false,
    entrypoint: 'ipfs',
    arguments: [ 'id' ],
    privileged: false
  },
  OpenStdin: true,
  OpenStderr: true,
  OpenStdout: true,
  CanRemove: false,
  ContainerID: '4a798e6f7c0228179e39e9118cba13169db9c4978f4c78556f4abfaf689ab9d5',
  DetachKeys: '',
  Pid: 0
}

id:
{
  ID: '489d727549dc740669282cad70f912baeac3723c959effcdc8f9330191d9fdd4',
  Running: true,
  ExitCode: null,
  ProcessConfig: {
    tty: false,
    entrypoint: 'ipfs',
    arguments: [ 'id' ],
    privileged: false
  },
  OpenStdin: true,
  OpenStderr: true,
  OpenStdout: true,
  CanRemove: false,
  ContainerID: '4a798e6f7c0228179e39e9118cba13169db9c4978f4c78556f4abfaf689ab9d5',
  DetachKeys: '',
  Pid: 0
}
{
        "ID": "12D3KooWSzQfouQU1U8Wm2nmrgxuoM5bQVq7GSW6RJjtB7bLKH7q",
        "PublicKey": "CAESIP8pUFmDcym4V8gTff1NR2ybaBqbVa1jkzE3xYTyIduM",
        "Addresses": [
                "/ip4/127.0.0.1/tcp/4001/p2p/12D3KooWSzQfouQU1U8Wm2nmrgxuoM5bQVq7GSW6RJjtB7bLKH7q",
                "/ip4/192.168.0.2/tcp/4001/p2p/12D3KooWSzQfouQU1U8Wm2nmrgxuoM5bQVq7GSW6RJjtB7bLKH7q"
        ],
        "AgentVersion": "kubo/0.19.1/958e586/docker",
        "ProtocolVersion": "ipfs/0.1.0",
        "Protocols": [
                "/ipfs/bitswap",
                "/ipfs/bitswap/1.0.0",
                "/ipfs/bitswap/1.1.0",
                "/ipfs/bitswap/1.2.0",
                "/ipfs/id/1.0.0",
                "/ipfs/id/push/1.0.0",
                "/ipfs/lan/kad/1.0.0",
                "/ipfs/ping/1.0.0",
                "/libp2p/autonat/1.0.0",
                "/libp2p/circuit/relay/0.2.0/stop",
                "/x/"
        ]
}

the last json containing ID, Publickey, etc. is what i need, but that is not part of the returned value from runExec function.
is there a way to receive this result as a return value of a runExec function?

[apocas]

Hi, we have a few examples of this in dockerode tests :)
I believe this is similar to what you want: https://github.com/apocas/dockerode/blob/v3.3.5/test/container.js#L635

[anthonator]

Replicating docker exec is deceptively complex. For anyone else continuing to struggle with this here is a function I put together which does the job.

import stream from "stream";
import streamPromises from "stream/promises";

import Docker from "dockerode";

const docker = new Docker();

/**
 * Interface for the output of a Docker exec command.
 */
interface DockerExecOutput {
  /**
   * Exit code of the process.
   */
  exitCode: number | null;

  /**
   * Stdout of the process as a string.
   */
  stderr: string;

  /**
   * Stderr of the process as a string.
   */
  stdout: string;
}

/**
 * Execute a command in a running Docker container.
 *
 * @param container container to execute the command in
 * @param cmd command to execute
 * @param opts options passed to the Docker Engine API
 */
export async function exec(
  container: Docker.Container,
  cmd: string[],
  opts?: Docker.ExecCreateOptions,
): Promise<DockerExecOutput> {
  const dockerExec = await container.exec({
    ...opts,
    AttachStderr: true,
    AttachStdout: true,
    Cmd: cmd,
  });

  const dockerExecStream = await dockerExec.start({});

  const stdoutStream = new stream.PassThrough();
  const stderrStream = new stream.PassThrough();

  docker.modem.demuxStream(dockerExecStream, stdoutStream, stderrStream);

  dockerExecStream.resume();

  await streamPromises.finished(dockerExecStream);

  const stderr = stderrStream.read() as Buffer | undefined;
  const stdout = stdoutStream.read() as Buffer | undefined;

  const dockerExecInfo = await dockerExec.inspect();

  return {
    exitCode: dockerExecInfo.ExitCode,
    stderr: stderr?.toString(),
    stdout: stdout?.toString(),
  };
}

[davidkhala]

The best help for my 2023!

[slidenerd]

import { PassThrough } from "node:stream";
import { finished } from "node:stream/promises";


export async function executeCommandInContainerBuffer(
	command: string,
	container: Container,
	execCreateOptions: ExecCreateOptions = {},
	execStartOptions: ExecStartOptions = {},
): Promise<CommandResult> {
	const stdoutChunks: Buffer[] = [];
	const stderrChunks: Buffer[] = [];

	const outStream = new PassThrough();
	const errStream = new PassThrough();

	outStream.on("data", (chunk) => stdoutChunks.push(chunk));
	errStream.on("data", (chunk) => stderrChunks.push(chunk));

	try {
		const exec = await container.exec({
			Cmd: ["/bin/bash", "-c", command],
			AttachStdout: true,
			AttachStderr: true,
			Tty: false,
			...execCreateOptions,
		});

		const stream = await exec.start(execStartOptions);

		container.modem.demuxStream(stream, outStream, errStream);

		await finished(stream);

		const stdOut = Buffer.concat(stdoutChunks).toString("utf8");
		const stdErr = Buffer.concat(stderrChunks).toString("utf8");

		const execInspectInfo = await exec.inspect();
		const exitCode = execInspectInfo.ExitCode ?? 0;

		// When Tty: true, stdout contains the error message from bad commands
		// When Tty: false, stderr contains the error message from bad commands
		return { exitCode, stdOut, stdErr };
	} catch (error) {
		logger.error(
			error,
			"Error executing command:%s in container:id %s",
			command,
			container.id,
		);
		return {
			exitCode: -1,
			stdErr: error instanceof Error ? error.message : String(error),
			stdOut: "",
		};
	}
}

export async function executeCommandInContainerString(
	command: string,
	container: Container,
	execCreateOptions: ExecCreateOptions = {},
	execStartOptions: ExecStartOptions = {},
): Promise<CommandResult> {
	const stdoutChunks: string[] = [];
	const stderrChunks: string[] = [];

	const outStream = new PassThrough();
	const errStream = new PassThrough();

	outStream.setEncoding("utf-8");
	errStream.setEncoding("utf-8");

	outStream.on("data", (chunk) => stdoutChunks.push(chunk));
	errStream.on("data", (chunk) => stderrChunks.push(chunk));

	try {
		const exec = await container.exec({
			Cmd: ["/bin/bash", "-c", command],
			AttachStdout: true,
			AttachStderr: true,
			Tty: false,
			...execCreateOptions,
		});

		const stream = await exec.start(execStartOptions);

		container.modem.demuxStream(stream, outStream, errStream);

		await finished(stream);

		const stdOut = stdoutChunks.join("");
		const stdErr = stderrChunks.join("");

		const execInspectInfo = await exec.inspect();
		const exitCode = execInspectInfo.ExitCode ?? 0;

		// When Tty: true, stdout contains the error message from bad commands
		// When Tty: false, stderr contains the error message from bad commands
		return { exitCode, stdOut, stdErr };
	} catch (error) {
		logger.error(
			error,
			"Error executing command:%s in container:id %s",
			command,
			container.id,
		);
		return {
			exitCode: -1,
			stdErr: error instanceof Error ? error.message : String(error),
			stdOut: "",
		};
	}
}

• works a lot faster than the above one, you can try benchmarking both

[davidkhala]

I am a little supprise on the catch section in this type of func. Any specific reason that we need it?

[slidenerd]

well you could probably omit the catch entirely and let the caller deal with it i suppose or you could add a catch at each await statement and then handle errors specifically. It all depends I guess. But to answer your question, only reason I added a catch was because there were too many awaits inside that function 🤣