package org.kuali.common.devops.docker;
   
   import static com.google.common.base.Preconditions.checkState;
   import static java.lang.String.format;
   import static org.apache.commons.io.IOUtils.closeQuietly;
   import static org.kuali.common.core.io.Files.getCanonicalFile;
   import static org.kuali.common.util.FormatUtils.getTime;
   import static org.kuali.common.util.log.Loggers.newLogger;
   
  import java.io.File;
  import java.io.InputStream;
  
  import org.junit.Test;
  import org.kuali.common.core.json.api.JsonService;
  import org.kuali.common.core.json.jackson.JacksonJsonService;
  import org.slf4j.Logger;
  
  import com.amazonaws.util.IOUtils;
  import com.fasterxml.jackson.databind.JsonNode;
  import com.github.dockerjava.api.DockerClient;
  import com.github.dockerjava.core.DockerClientBuilder;
  import com.google.common.base.Splitter;
  import com.google.common.base.Stopwatch;
  
  public class DockerBuildImageTest {
  
      private static final Logger logger = newLogger();
  
      @Test
      public void test() {
          try {
              String url = "http://localhost:2375";
              DockerClient client = DockerClientBuilder.getInstance(url).build();
              File folder = getCanonicalFile("./src/main/resources/org/kuali/common/kuali-devops/docker/jcaddel/ubuntu");
              String tag = "jcaddel/ubuntu:trusty";
              InputStream response = client.buildImageCmd(folder).withTag(tag).exec();
              String content = IOUtils.toString(response);
              closeQuietly(response);
              JsonService json = new JacksonJsonService();
              JsonNode node = json.readString(content, JsonNode.class);
              info(json, node);
          } catch (Throwable e) {
              e.printStackTrace();
          }
      }
  
      /**
       * Convert the object reference to json.
       *
       * Create a new object instance from the json and then create a new json string from the new object instance.
       *
       * Verify that the original json string and the new json string are exactly the same.
       */
      protected static <T> T checkPerfectReadWrite(JsonService json, T reference, Class<T> type) {
          String expected = json.writeString(reference);
          String actual = json.writeString(json.readString(expected, type));
          checkState(expected.equals(actual));
          return reference;
      }
  
      protected static void elapsed(Stopwatch sw) {
          info("elapsed -> %s", getTime(sw));
      }
  
      protected static <T> void info(JsonService json, T reference) {
          String text = json.writeString(reference);
          Iterable<String> lines = Splitter.on('\n').split(text);
          for (String line : lines) {
              info("%s", line);
          }
      }
  
      protected static void debug(String msg, Object... args) {
          logger.debug((args == null || args.length == 0) ? msg : format(msg, args));
      }
  
      protected static void info(String msg, Object... args) {
          logger.info((args == null || args.length == 0) ? msg : format(msg, args));
      }
  
  }