async function buildDocker(dir: string, tag: string): Promise<{}> {
  const tarStream = tar.pack(dir);
  const stream = await DOCKER.buildImage(tarStream, {t: tag});

  let resolve: (output: {}) => void;
  let reject: (err: Error) => void;
  const promise = new Promise((res, rej) => {
    resolve = res;
    reject = rej;
  });

  function onFinished(err: Error, output: {}) {
    if (err) {
      return reject(err);
    }

    resolve(output);
  }

  function onProgress(
      event: {stream?: string; status?: string; progress?: string;}) {
    log(event.stream);
    log(event.status);
    log(event.progress);
  }

  DOCKER.modem.followProgress(stream, onFinished, onProgress);
  return promise;
}

 async addContent(workspaceId: string,
   definition: WorkspaceDefinition,
   container: dockerode.Container,
   progress: (string) => void)
   : Promise<void> {
     let sourcePath = path.resolve(this.params.path);
     if (!fs.existsSync(sourcePath)) {
       logger.error("[ %s ] source path do not exists: %s", workspaceId, sourcePath);
       throw ("source path do not exists: " + sourcePath);
     }
     if (path.extname(sourcePath) != "tar") {
       logger.debug("[ %s ] making a tar file with the provided content: %s", workspaceId, sourcePath);
       const parentDir = path.join(os.tmpdir(), "docker-workspace");
       if(!fs.existsSync(parentDir)) {
         fs.mkdirSync(parentDir);
       }
       let tempDir = fs.mkdtempSync(path.join(parentDir, "fsCopy-"));
       let tarPath = path.join(tempDir, workspaceId+"-code.tar");
       logger.debug("[ %s ] creating tar file : %s", workspaceId, tarPath);
       tar.pack(sourcePath).pipe(fs.createWriteStream(tarPath))
           .on("finish", async () => {
             await putArchive(workspaceId, container, tarPath, definition.development.code.path);
             return;
       });
     } else {
       await putArchive(workspaceId, container, sourcePath, definition.development.code.path);
       return;
     }
 }

 let promise = new Promise<string>((resolve, reject) => {
     const logger = loggerFactory(referenceInfo, output)
     const tarFileName = referenceInfo.replace(/[\/\\]/, "_");
     const tempDir = fs.mkdtempSync(path.join(parentDir, tarFileName));
     const tarPath = path.join(tempDir, tarFileName + ".tar");
     const sourcePath = path.resolve(imagePath);
     logger.debug("creating tar file : %s from %s", tarPath, sourcePath);
     tar.pack(sourcePath).pipe(fs.createWriteStream(tarPath))
         .on("finish", () => {
             resolve(tarPath);
         })
         .on("error", reject);
 })

export function GenerateTarGz(src, dest, cb) {
  debug("GenerateTarGz");

  // A list of file extensions that should be packaged into the .tar.gz.
  // Files with all other file extenstions will be excluded to minimize the size
  // of the deployment transaction payload.
  var keep = [
    ".go",
    ".yaml",
    ".json",
    ".c",
    ".h",
    ".pem"
  ];

  // Create the pack stream specifying the ignore/filtering function
  var pack = tar.pack(src, {
    ignore: function(name) {
      // Check whether the entry is a file or a directory
      if (fs.statSync(name).isDirectory()) {
        // If the entry is a directory, keep it in order to examine it further
        return false
      } else {
        // If the entry is a file, check to see if it's the Dockerfile
        if (name.indexOf("Dockerfile") > -1) {
          return false
        }

        // If it is not the Dockerfile, check its extension
        var ext = path.extname(name);

        // Ignore any file who's extension is not in the keep list
        if (keep.indexOf(ext) === -1) {
          return true
        } else {
          return false
        }
      }
    }
  })
  .pipe(zlib.Gzip())
  .pipe(fs.createWriteStream(dest));

  pack.on("close", function() {
    return cb(null);
  });
  pack.on("error", function() {
    return cb(Error("Error on fs.createWriteStream"));
  });
}