private TestExecStartResultCallback executeCommandInDocker(String containerName, String[] command,
    boolean expectedToSucceed) throws Exception {
  Container sparkWorkerContainer = runningContainers.get(containerName);
  ExecCreateCmd cmd = dockerClient.execCreateCmd(sparkWorkerContainer.getId()).withCmd(command).withAttachStdout(true)
      .withAttachStderr(true);

  ExecCreateCmdResponse createCmdResponse = cmd.exec();
  TestExecStartResultCallback callback =
      new TestExecStartResultCallback(new ByteArrayOutputStream(), new ByteArrayOutputStream());
  dockerClient.execStartCmd(createCmdResponse.getId()).withDetach(false).withTty(false).exec(callback)
      .awaitCompletion();
  int exitCode = dockerClient.inspectExecCmd(createCmdResponse.getId()).exec().getExitCode();
  LOG.info("Exit code for command : " + exitCode);
  LOG.error("\n\n ###### Stdout #######\n" + callback.getStdout().toString());
  LOG.error("\n\n ###### Stderr #######\n" + callback.getStderr().toString());

  if (expectedToSucceed) {
    assertEquals(0, exitCode, "Command (" + Arrays.toString(command) + ") expected to succeed. Exit (" + exitCode + ")");
  } else {
    assertNotEquals(0, exitCode, "Command (" + Arrays.toString(command) + ") expected to fail. Exit (" + exitCode + ")");
  }
  cmd.close();
  return callback;
}
 

@Override
public Boolean call() throws Exception {
    ExecCreateCmdResponse execResponse = getDockerClient().execCreateCmd(containerId)
            .withCmd("ls", "-R", dataDirectory)
            .withTty(true)
            .withAttachStdout(true)
            .withAttachStderr(true)
            .exec();
    try (InputStream inputstream = getDockerClient().execStartCmd(containerId).withTty(true).withExecId(execResponse.getId()).exec(null)) {
        String contents = IOUtils.toString(inputstream, Charset.defaultCharset()).replaceAll("\\p{C}", "");
        LOGGER.info("Contents of " + dataDirectory + ": " + contents);
        return contents.contains("S0") && contents.contains("S1") && contents.contains("S2");
    } catch (IOException e) {
        LOGGER.error("Could not list contents of " + dataDirectory + " in Mesos-Local");
        return false;
    }
}
 

public String execCommand(String containerId, boolean awaitCompletion, String... command) {
  ExecCreateCmdResponse exec = client.execCreateCmd(containerId).withCmd(command).withTty(false)
      .withAttachStdin(true).withAttachStdout(true).withAttachStderr(true).exec();
  ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  String output = null;
  try {
    ExecStartResultCallback resultCallback = client.execStartCmd(exec.getId()).withDetach(false)
        .withTty(true).exec(new ExecStartResultCallback(outputStream, System.err));
    if (awaitCompletion) {
        resultCallback.awaitCompletion();
    }
    output = new String(outputStream.toByteArray());
  } catch (InterruptedException e) {
    log.warn("Exception executing command {} on container {}", Arrays.toString(command),
        containerId, e);
  }

  return output;
}
 

public void execCommand( String command ) throws Exception {
        // Exec command inside running container with attached STDOUT and STDERR
        String[] commandArray = StringUtilities.parseCommand(command);

        ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(containerId)//
                .withAttachStdout(true) //
                .withAttachStderr(true)//
                .withCmd(commandArray)//
                .withUser("root")//
                .exec();
        dockerClient.execStartCmd(execCreateCmdResponse.getId()).exec(new ExecStartResultCallback(System.out, System.err))
                .awaitCompletion();

//            pm.message(execOutput);

    }
 

@Test
public void execStartAttached() throws Exception {
    String containerName = "generated_" + new SecureRandom().nextInt();

    CreateContainerResponse container = dockerRule.getClient().createContainerCmd("busybox").withCmd("sleep", "9999")
            .withName(containerName).exec();
    LOG.info("Created container {}", container.toString());
    assertThat(container.getId(), not(is(emptyString())));

    dockerRule.getClient().startContainerCmd(container.getId()).exec();

    ExecCreateCmdResponse execCreateCmdResponse = dockerRule.getClient().execCreateCmd(container.getId())
            .withAttachStdout(true).withCmd("touch", "/execStartTest.log").exec();
    dockerRule.getClient().execStartCmd(execCreateCmdResponse.getId()).withDetach(false).withTty(true)
            .exec(new ExecStartResultCallback(System.out, System.err)).awaitCompletion();

    InputStream response = dockerRule.getClient().copyArchiveFromContainerCmd(container.getId(), "/execStartTest.log").exec();

    // read the stream fully. Otherwise, the underlying stream will not be closed.
    String responseAsString = asString(response);
    assertNotNull(responseAsString);
    assertTrue(responseAsString.length() > 0);
}
 

@Test(expected = NotFoundException.class)
public void execStartWithNonExistentUser() throws Exception {
    String containerName = "generated_" + new SecureRandom().nextInt();

    CreateContainerResponse container = dockerRule.getClient().createContainerCmd("busybox").withCmd("sleep", "9999")
            .withName(containerName).exec();
    LOG.info("Created container {}", container.toString());
    assertThat(container.getId(), not(is(emptyString())));

    dockerRule.getClient().startContainerCmd(container.getId()).exec();

    ExecCreateCmdResponse execCreateCmdResponse = dockerRule.getClient().execCreateCmd(container.getId())
            .withAttachStdout(true).withCmd("touch", "/execStartTest.log").withUser("NonExistentUser").exec();
    dockerRule.getClient().execStartCmd(execCreateCmdResponse.getId()).withDetach(false).withTty(true)
            .exec(new ExecStartResultCallback(System.out, System.err)).awaitCompletion();

    dockerRule.getClient().copyArchiveFromContainerCmd(container.getId(), "/execStartTest.log").exec();
}
 

private void startZookeeper() {
    LOGGER.info("Starting zookeeper...");
    LOGGER.info("Executing command in container with Id {}", getContainerId());

    ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(getContainerId())
        .withCmd("bash", "-c", "bin/zookeeper-server-start.sh config/zookeeper.properties &")
        .exec();

    try {
        dockerClient.execStartCmd(execCreateCmdResponse.getId()).start().awaitCompletion(10, TimeUnit.SECONDS);

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
 

private void startKafka() {
    LOGGER.info("Starting kafka...");

    ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(getContainerId())
        .withCmd("bash", "-c", "bin/kafka-server-start.sh config/server.properties --override listeners=BROKER://0.0.0.0:9093,PLAINTEXT://0.0.0.0:" + KAFKA_PORT + "  --override advertised.listeners=" + advertisedListeners.toString() + " --override zookeeper.connect=localhost:" + ZOOKEEPER_PORT + " --override listener.security.protocol.map=BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT --override inter.broker.listener.name=BROKER &")
        .exec();

    try {
        dockerClient.execStartCmd(execCreateCmdResponse.getId()).start().awaitCompletion(10, TimeUnit.SECONDS);

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
 

@Override
public ProcessResult executeInContainerAsUser(ContainerName containerName, String user, OptionalLong timeoutSeconds, String... command) {
    try {
        ExecCreateCmdResponse response = execCreateCmd(containerName, user, command);

        ByteArrayOutputStream output = new ByteArrayOutputStream();
        ByteArrayOutputStream errors = new ByteArrayOutputStream();
        ExecStartResultCallback callback = dockerClient.execStartCmd(response.getId())
                .exec(new ExecStartResultCallback(output, errors));

        if (timeoutSeconds.isPresent()) {
            if (!callback.awaitCompletion(timeoutSeconds.getAsLong(), TimeUnit.SECONDS))
                throw new DockerExecTimeoutException(String.format(
                        "Command '%s' did not finish within %d seconds.", command[0], timeoutSeconds.getAsLong()));
        } else {
            // Wait for completion no timeout
            callback.awaitCompletion();
        }

        InspectExecResponse state = dockerClient.inspectExecCmd(response.getId()).exec();
        if (state.isRunning())
            throw new DockerException("Command '%s' did not finish within %s seconds.");

        return new ProcessResult(state.getExitCode(), new String(output.toByteArray()), new String(errors.toByteArray()));
    } catch (RuntimeException | InterruptedException e) {
        numberOfDockerApiFails.increment();
        throw new DockerException("Container '" + containerName.asString()
                + "' failed to execute " + Arrays.toString(command), e);
    }
}
 

private ExecCreateCmdResponse execCreateCmd(ContainerName containerName, String user, String... command) {
    try {
        return dockerClient.execCreateCmd(containerName.asString())
                .withCmd(command)
                .withAttachStdout(true)
                .withAttachStderr(true)
                .withUser(user)
                .exec();
    } catch (NotFoundException e) {
        throw new ContainerNotFoundException(containerName);
    }
}
 

@Test
public void testExecuteCompletes() {
    final String containerId = "container-id";
    final String[] command = new String[] {"/bin/ls", "-l"};
    final String execId = "exec-id";
    final int exitCode = 3;

    final ExecCreateCmdResponse response = mock(ExecCreateCmdResponse.class);
    when(response.getId()).thenReturn(execId);

    final ExecCreateCmd execCreateCmd = mock(ExecCreateCmd.class);
    when(dockerClient.execCreateCmd(any(String.class))).thenReturn(execCreateCmd);
    when(execCreateCmd.withCmd(ArgumentMatchers.<String>any())).thenReturn(execCreateCmd);
    when(execCreateCmd.withAttachStdout(any(Boolean.class))).thenReturn(execCreateCmd);
    when(execCreateCmd.withAttachStderr(any(Boolean.class))).thenReturn(execCreateCmd);
    when(execCreateCmd.withUser(any(String.class))).thenReturn(execCreateCmd);
    when(execCreateCmd.exec()).thenReturn(response);

    final ExecStartCmd execStartCmd = mock(ExecStartCmd.class);
    when(dockerClient.execStartCmd(any(String.class))).thenReturn(execStartCmd);
    when(execStartCmd.exec(any(ExecStartResultCallback.class))).thenReturn(mock(ExecStartResultCallback.class));

    final InspectExecCmd inspectExecCmd = mock(InspectExecCmd.class);
    final InspectExecResponse state = mock(InspectExecResponse.class);
    when(dockerClient.inspectExecCmd(any(String.class))).thenReturn(inspectExecCmd);
    when(inspectExecCmd.exec()).thenReturn(state);
    when(state.isRunning()).thenReturn(false);
    when(state.getExitCode()).thenReturn(exitCode);

    final ProcessResult result = docker.executeInContainerAsUser(
            new ContainerName(containerId), "root", OptionalLong.empty(), command);
    assertThat(result.getExitStatus(), is(exitCode));
}
 

/**
 * @param id The container id, will be used only the first one
 * @param serviceName Service name in running environment. Can be null.
 * @param script Script to execute
 */
@Override
public void execScript(List<String> id, String serviceName, String script) {
    log.info(String.format("Executing script: %s, in container: %s", script, id));

    String[] commands = null;
    try {
        /**
         * Due to permissions problems with mounted volume script is moved to some local directory in container
         *
         * 1. create new directory in container
         * 2. move there script
         * 3. chmod script
         * 4. execute script
         */
        commands = new String[] {
            "bash", "-c",
            scriptExecCommand(script)
        };

        ExecCreateCmdResponse exec = dockerClient.execCreateCmd(id.get(0))
                .withCmd(commands)
                .withAttachStdout(true)
                .withAttachStderr(true)
                .exec();

        dockerClient.execStartCmd(exec.getId())
                .exec(new ExecStartResultCallback(System.out, System.err))
                .awaitCompletion();
    } catch (DockerException | InterruptedException ex) {
        log.severe(String.format("Could not execute command: %s", Arrays.toString(commands)));
        throw new EnvironmentException("Could not execute command " + Arrays.toString(commands), ex);
    }
}
 

@SneakyThrows(InterruptedException.class)
private String startZookeeper() {
    ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(getContainerId())
        .withCmd("sh", "-c", "" +
            "printf 'clientPort=" + ZOOKEEPER_PORT + "\ndataDir=/var/lib/zookeeper/data\ndataLogDir=/var/lib/zookeeper/log' > /zookeeper.properties\n" +
            "zookeeper-server-start /zookeeper.properties\n"
        )
        .exec();

    dockerClient.execStartCmd(execCreateCmdResponse.getId()).start().awaitStarted(10, TimeUnit.SECONDS);

    return "localhost:" + ZOOKEEPER_PORT;
}
 

public String getContentOfFile(String path){
    ExecCreateCmdResponse execCreateCmdResponse;

    execCreateCmdResponse = dockerClient
        .execCreateCmd(executorId)
        .withAttachStdout(true)
        .withCmd("cat", path).exec();

    final ExecCreateCmdResponse finalExecCreateCmdResponse = execCreateCmdResponse;

    return ResponseCollector.collectResponse(dockerClient
        .execStartCmd(finalExecCreateCmdResponse.getId()).exec());
}
 

private void writeToFile(String op, String dest, String content) {
    ExecCreateCmdResponse execCreateCmdResponse;
    InputStream execCmdStream;

    execCreateCmdResponse = dockerClient
        .execCreateCmd(mesosLocalContainerID)
        .withAttachStdout(true)
        .withCmd("sh", "-c", "echo \"" + content + "\" " + op + " " + dest).exec();

    execCmdStream = dockerClient.execStartCmd(execCreateCmdResponse.getId()).exec();
    System.out.println(ResponseCollector.collectResponse(execCmdStream));
}
 

@Test
public void execStart() throws Exception {
    assumeNotSwarm("no network in swarm", dockerRule);

    String containerName = "generated_" + new SecureRandom().nextInt();

    CreateContainerResponse container = dockerRule.getClient().createContainerCmd("busybox").withCmd("top")
            .withName(containerName).exec();
    LOG.info("Created container {}", container.toString());
    assertThat(container.getId(), not(is(emptyString())));

    dockerRule.getClient().startContainerCmd(container.getId()).exec();

    ExecCreateCmdResponse execCreateCmdResponse = dockerRule.getClient().execCreateCmd(container.getId())
            .withAttachStdout(true)
            .withCmd("touch", "/execStartTest.log")
            .withUser("root")
            .exec();
    dockerRule.getClient().execStartCmd(execCreateCmdResponse.getId())
            .exec(new ExecStartResultCallback(System.out, System.err))
            .awaitCompletion();

    InputStream response = dockerRule.getClient().copyArchiveFromContainerCmd(container.getId(), "/execStartTest.log").exec();

    // read the stream fully. Otherwise, the underlying stream will not be closed.
    String responseAsString = asString(response);
    assertNotNull(responseAsString);
    assertTrue(responseAsString.length() > 0);
}
 

@Override
protected ExecCreateCmdResponse execute(ExecCreateCmd command) {
    WebTarget webResource = getBaseResource().path("/containers/{id}/exec").resolveTemplate("id",
            command.getContainerId());

    LOGGER.trace("POST: {}", webResource);

    return webResource.request().accept(MediaType.APPLICATION_JSON)
            .post(command, new TypeReference<ExecCreateCmdResponse>() {
            });
}
 

/**
 * Run a command inside a running container, as though using "docker exec".
 * <p>
 * This functionality is not available on a docker daemon running the older "lxc" execution driver. At
 * the time of writing, CircleCI was using this driver.
 * @param containerInfo the container info
 * @param outputCharset the character set used to interpret the output.
 * @param command the parts of the command to run
 * @return the result of execution
 * @throws IOException if there's an issue communicating with Docker
 * @throws InterruptedException if the thread waiting for the response is interrupted
 * @throws UnsupportedOperationException if the docker daemon you're connecting to doesn't support "exec".
 */
public Container.ExecResult execInContainer(InspectContainerResponse containerInfo, Charset outputCharset, String... command)
    throws UnsupportedOperationException, IOException, InterruptedException {
    if (!TestEnvironment.dockerExecutionDriverSupportsExec()) {
        // at time of writing, this is the expected result in CircleCI.
        throw new UnsupportedOperationException(
            "Your docker daemon is running the \"lxc\" driver, which doesn't support \"docker exec\".");

    }

    if (!isRunning(containerInfo)) {
        throw new IllegalStateException("execInContainer can only be used while the Container is running");
    }

    String containerId = containerInfo.getId();
    String containerName = containerInfo.getName();

    DockerClient dockerClient = DockerClientFactory.instance().client();

    log.debug("{}: Running \"exec\" command: {}", containerName, String.join(" ", command));
    final ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(containerId)
        .withAttachStdout(true).withAttachStderr(true).withCmd(command).exec();

    final ToStringConsumer stdoutConsumer = new ToStringConsumer();
    final ToStringConsumer stderrConsumer = new ToStringConsumer();

    try (FrameConsumerResultCallback callback = new FrameConsumerResultCallback()) {
        callback.addConsumer(OutputFrame.OutputType.STDOUT, stdoutConsumer);
        callback.addConsumer(OutputFrame.OutputType.STDERR, stderrConsumer);

        dockerClient.execStartCmd(execCreateCmdResponse.getId()).exec(callback).awaitCompletion();
    }
    Integer exitCode = dockerClient.inspectExecCmd(execCreateCmdResponse.getId()).exec().getExitCode();

    final Container.ExecResult result = new Container.ExecResult(
        exitCode,
        stdoutConsumer.toString(outputCharset),
        stderrConsumer.toString(outputCharset));

    log.trace("{}: stdout: {}", containerName, result.getStdout());
    log.trace("{}: stderr: {}", containerName, result.getStderr());
    return result;
}
 

@Test
public void execCreateTest() {
    String containerName = "generated_" + new SecureRandom().nextInt();

    CreateContainerResponse container = dockerRule.getClient().createContainerCmd(DEFAULT_IMAGE).withUser("root").withCmd("top")
            .withName(containerName).exec();

    LOG.info("Created container {}", container.toString());

    assertThat(container.getId(), not(is(emptyString())));

    dockerRule.getClient().startContainerCmd(container.getId()).exec();

    ExecCreateCmdResponse execCreateCmdResponse = dockerRule.getClient().execCreateCmd(container.getId())
            .withCmd("touch", "file.log").exec();

    assertThat(execCreateCmdResponse.getId(), not(is(emptyString())));
}
 

@Test
public void resizeExecInstanceTtyTest() throws Exception {
    String containerName = "generated_" + new SecureRandom().nextInt();

    CreateContainerResponse container = dockerRule.getClient().createContainerCmd("busybox").withUser("root")
            .withCmd("sleep", "9999").withName(containerName).exec();

    dockerRule.getClient().startContainerCmd(container.getId()).exec();

    // wait until tty size changed to target size
    ExecCreateCmdResponse execCreateCmdResponse = dockerRule.getClient().execCreateCmd(container.getId()).withTty(true)
        .withAttachStdout(true).withAttachStderr(true)
        .withCmd("sh", "-c", String.format("until stty size | grep '%d %d'; do : ; done", TTY_HEIGHT, TTY_WIDTH)).exec();

    final ExecStartResultCallback execStartResultCallback = new ExecStartResultCallback(System.out, System.err);

    dockerRule.getClient().execStartCmd(execCreateCmdResponse.getId()).exec(execStartResultCallback).awaitStarted();

    dockerRule.getClient().resizeExecCmd(execCreateCmdResponse.getId()).withSize(TTY_HEIGHT, TTY_WIDTH).exec();

    // time out, exec instance resize failed
    boolean waitResult = execStartResultCallback.awaitCompletion(10, TimeUnit.SECONDS);

    assertThat(waitResult, equalTo(true));
}
 

@Test
public void inspectExec() throws Exception {
    String containerName = "generated_" + new SecureRandom().nextInt();

    CreateContainerResponse container = dockerRule.getClient().createContainerCmd("busybox").withCmd("sleep", "9999")
            .withName(containerName).exec();
    LOG.info("Created container {}", container.toString());
    assertThat(container.getId(), not(is(emptyString())));

    dockerRule.getClient().startContainerCmd(container.getId()).exec();

    // Check that file does not exist
    ExecCreateCmdResponse checkFileExec1 = dockerRule.getClient().execCreateCmd(container.getId()).withAttachStdout(true)
            .withAttachStderr(true).withCmd("test", "-e", "/marker").exec();
    LOG.info("Created exec {}", checkFileExec1.toString());
    assertThat(checkFileExec1.getId(), not(is(emptyString())));
    dockerRule.getClient().execStartCmd(checkFileExec1.getId()).withDetach(false)
            .exec(new ExecStartResultCallback(System.out, System.err)).awaitCompletion();
    InspectExecResponse first = dockerRule.getClient().inspectExecCmd(checkFileExec1.getId()).exec();
    assertThat(first.isRunning(), is(false));
    assertThat(first.getExitCode(), is(1));

    // Create the file
    ExecCreateCmdResponse touchFileExec = dockerRule.getClient().execCreateCmd(container.getId()).withAttachStdout(true)
            .withAttachStderr(true).withCmd("touch", "/marker").exec();
    LOG.info("Created exec {}", touchFileExec.toString());
    assertThat(touchFileExec.getId(), not(is(emptyString())));
    dockerRule.getClient().execStartCmd(touchFileExec.getId()).withDetach(false)
            .exec(new ExecStartResultCallback(System.out, System.err)).awaitCompletion();
    InspectExecResponse second = dockerRule.getClient().inspectExecCmd(touchFileExec.getId()).exec();
    assertThat(second.isRunning(), is(false));
    assertThat(second.getExitCode(), is(0));

    // Check that file does exist now
    ExecCreateCmdResponse checkFileExec2 = dockerRule.getClient().execCreateCmd(container.getId()).withAttachStdout(true)
            .withAttachStderr(true).withCmd("test", "-e", "/marker").exec();
    LOG.info("Created exec {}", checkFileExec2.toString());
    assertThat(checkFileExec2.getId(), not(is(emptyString())));
    dockerRule.getClient().execStartCmd(checkFileExec2.getId()).withDetach(false)
            .exec(new ExecStartResultCallback(System.out, System.err)).awaitCompletion();
    InspectExecResponse third = dockerRule.getClient().inspectExecCmd(checkFileExec2.getId()).exec();
    assertThat(third.isRunning(), is(false));
    assertThat(third.getExitCode(), is(0));

    // Get container info and check its roundtrip to ensure the consistency
    InspectContainerResponse containerInfo = dockerRule.getClient().inspectContainerCmd(container.getId()).exec();
    assertEquals(containerInfo.getId(), container.getId());
    JSONTestHelper.testRoundTrip(containerInfo);
}
 

/**
 * @throws NotFoundException
 *             No such container
 */
@Override
public ExecCreateCmdResponse exec() throws NotFoundException {
    return super.exec();
}
 

@Override
public void launch(final SlaveComputer computer, TaskListener listener) throws IOException, InterruptedException {
    final PrintStream logger = computer.getListener().getLogger();
    final String jenkinsUrl = Jenkins.getInstance().getRootUrl();
    final String effectiveJavaExe = StringUtils.isNotBlank(javaExeOrNull) ? javaExeOrNull : DEFAULT_JAVA_EXE;
    final String effectiveJvmArgs = StringUtils.isNotBlank(jvmArgsOrEmpty) ? jvmArgsOrEmpty : DEFAULT_JVM_ARGS ;
    final EnvVars knownVariables = calculateVariablesForVariableSubstitution(effectiveJavaExe, effectiveJvmArgs, remoting.getName(), remoteFs, jenkinsUrl);
    final String effectiveEntryPointCmdString = StringUtils.isNotBlank(entryPointCmdOrEmpty) ? entryPointCmdOrEmpty : DEFAULT_ENTRY_POINT_CMD_STRING;
    final String resolvedEntryPointCmdString = Util.replaceMacro(effectiveEntryPointCmdString, knownVariables);
    final String[] resolvedEntryPointCmd = splitAndFilterEmpty(resolvedEntryPointCmdString, "\n");
    logger.println("Connecting to docker container " + containerId + ", running command " + Joiner.on(" ").join(resolvedEntryPointCmd));

    final String execId;
    try(final DockerClient client = api.getClient()) {
        final ExecCreateCmd cmd = client.execCreateCmd(containerId)
                .withAttachStdin(true)
                .withAttachStdout(true)
                .withAttachStderr(true)
                .withTty(false)
                .withCmd(resolvedEntryPointCmd);
        if (StringUtils.isNotBlank(userOrNull)) {
            cmd.withUser(userOrNull);
        }
        final ExecCreateCmdResponse exec = cmd.exec();
        execId = exec.getId();
    }
    final String js = "{ \"Detach\": false, \"Tty\": false }";
    final Socket socket = api.getSocket();
    final OutputStream out = socket.getOutputStream();
    final InputStream in = socket.getInputStream();
    final PrintWriter w = new PrintWriter(new OutputStreamWriter(out, StandardCharsets.US_ASCII));
    w.println("POST /v1.32/exec/" + execId + "/start HTTP/1.1");
    w.println("Host: docker.sock");
    w.println("Content-Type: application/json");
    w.println("Upgrade: tcp");
    w.println("Connection: Upgrade");
    w.println("Content-Length: " + js.length());
    w.println();
    w.println(js);
    w.flush();

    // read HTTP response headers
    String line = readLine(in);
    logger.println(line);
    if (! line.startsWith("HTTP/1.1 101 ")) {   // Switching Protocols
        throw new IOException("Unexpected HTTP response status line " + line);
    }

    // Skip HTTP header
    while ((line = readLine(in)).length() > 0) {
        if (line.length() == 0) break; // end of header
        logger.println(line);
    }

    final InputStream demux = new DockerMultiplexedInputStream(in);

    computer.setChannel(demux, out, listener, new Channel.Listener() {
        @Override
        public void onClosed(Channel channel, IOException cause) {
            // Bye!
        }
    });

}
 

public void exec(String id, String... cmd){
    ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(id)
            .withAttachStdout(true)
            .withCmd(cmd).exec();
}