httphijack | Use Javascript to implement front

package com.examenginedashboard.docker.utils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import com.examenginedashboard.CONSTANTS.MyValuesConstans; 
import com.examenginedashboard.codePG.service.HttpHijack;
import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.api.command.CreateContainerResponse;
import com.github.dockerjava.api.command.DockerCmdExecFactory;
import com.github.dockerjava.api.command.ExecCreateCmdResponse;
import com.github.dockerjava.api.command.InspectExecResponse;
import com.github.dockerjava.api.model.Bind;
import com.github.dockerjava.api.model.ExposedPort;
import com.github.dockerjava.api.model.Ports;
import com.github.dockerjava.api.model.Volume;
import com.github.dockerjava.core.DefaultDockerClientConfig;
import com.github.dockerjava.core.DockerClientBuilder;
import com.github.dockerjava.core.DockerClientConfig;
import com.github.dockerjava.core.command.ExecStartResultCallback;
import com.github.dockerjava.jaxrs.JerseyDockerCmdExecFactory;

 public class APIBasedCodeCompiler {

    public static void connectToDocker(){
        DockerCmdExecFactory dockerCmdExecFactory = new                                             JerseyDockerCmdExecFactory()
        .withReadTimeout(1000)
        .withConnectTimeout(1000)
        .withMaxTotalConnections(100)
        .withMaxPerRouteConnections(10);
        ExposedPort tcp22 = ExposedPort.tcp(22);
        ExposedPort tcp23 = ExposedPort.tcp(23);


        Ports portBindings = new Ports();
        portBindings.bind(tcp22, Ports.Binding.bindPort(11022));
        portBindings.bind(tcp23, Ports.Binding.bindPort(11023));

DockerClientConfig config = DefaultDockerClientConfig. createDefaultConfigBuilder()
                    .withDockerHost("tcp://127.0.0.1:2375")
                    .build();

        DockerClient docker = DockerClientBuilder.getInstance(config).build();

        Volume volume1 = new Volume("/mydockerbuild"); 
      CreateContainerResponse containerResp = docker.createContainerCmd("busybox")
                .withImage(MyValuesConstans.JAVA_DOCKER)
                .withCmd("sh", "-c", "while :; do sleep 1; done")
                .withAttachStderr(true)
                .withAttachStdout(true)
                .withAttachStdin(true)
                .withVolumes(volume1)
                .withBinds(new Bind("/home/itcostcut/mydockerbuild",volume1))
                .exec();
        String containerId = containerResp.getId();
        docker.startContainerCmd(containerId).exec();
        System.out.println("HOST........... ");
        ByteArrayOutputStream stdout = new ByteArrayOutputStream();
        ByteArrayOutputStream stderr = new ByteArrayOutputStream();


      final String[] command = {"bash", "-c", "cd mydockerbuild/ && javac NumberToWord.java  && java -cp . NumberToWord exit"};
        ExecCreateCmdResponse execCreateCmdResponse = docker.execCreateCmd(containerId)
                .withAttachStdout(true)
                .withAttachStderr(true)
                .withAttachStdin(true)
                .withCmd(command)
                .exec();
        InspectExecResponse inpect = docker.inspectExecCmd(execCreateCmdResponse.getId()).exec();
        System.out.println("Inspect Info........... "+inpect);
     HashMap headers = new HashMap<>();
        headers.put("Content-Type", "application/json");
        HttpHijack ws;
        // http://localhost:4243
        //unix:///var/run/docker.sock

            docker.execStartCmd(execCreateCmdResponse.getId()).exec(
                    new ExecStartResultCallback(stdout, stderr));


          System.out.println("Output: "+stdout.toString());
          System.out.println("Error: "+stderr.toString());

        try {
            ws = new HttpHijack(new URI("http://127.0.0.1:2375/v1.27/exec/" + execCreateCmdResponse.getId() + "/start"));
             String payload = "{\"Detach\": false,\"Tty\": false}";
                ws.post(headers, payload);
                String request = "10";
                //Thread.sleep(3000);
                InputStream input = ws.send(request);
                int expectedDataLength=5000;
                ByteArrayOutputStream baos = new ByteArrayOutputStream(expectedDataLength);
                byte[] chunk = new byte[expectedDataLength];
                int numBytesJustRead;
                while((numBytesJustRead = input.read(chunk)) != -1) {
                    baos.write(chunk, 0, numBytesJustRead);
                }
                System.out.println("Result ............... "+baos.toString());


        } catch (URISyntaxException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }}
      public static void main(String[] args){   
      connectToDocker();
       }}