How to use the dockerode function in dockerode

'docker.info'(dockerConfig) {
            let future = new Future();
            let testDocker = new Dockerode({
                host: dockerConfig.address,
                port: dockerConfig.port
            });
            testDocker.info((err, data) => {
                if (err) {
                    future.throw('cannot connect to Docker');
                    return;
                } else {
                    future.return(data);
                }
            });
            return future.wait();
        },
        // 'docker.listImage'() {

const defaultBuildConfig = await getBuildConfig(absoluteDir);
  const buildConfig = overrideBuildConfig(defaultBuildConfig, options);
  const buildContext = await createBuildContext(absoluteDir, buildConfig);
  const dockerImageTags = (buildConfig.tags || []).map(
    tag => `${buildConfig.name}:${tag}`
  );

  const getDaemonMessage = new Transform({
    writableObjectMode: true,
    transform(chunk, _, callback): void {
      const { stream, error } = chunk as any; // eslint-disable-line @typescript-eslint/no-explicit-any
      callback(error ? new Error(error) : undefined, stream || undefined);
    },
  });

  return new Dockerode()
    .buildImage(buildContext, {
      t: dockerImageTags,
      buildargs: {
        AUTH_TOKEN:
          buildConfig.pkgRegistryAuth && buildConfig.pkgRegistryAuth.token,
      },
    })
    .then(daemonStream =>
      daemonStream.pipe(split2(line => JSON.parse(line))).pipe(getDaemonMessage)
    );
};

// replace promises with bluebird
import Bluebird from 'bluebird';
import Docker from 'dockerode';

// promisify
Bluebird.promisifyAll(Docker.prototype);

// create new docker instance
const docker = new Docker(); // defaults to above if env variables are not used

// promisify network
const network = docker.getNetwork('promisify-net');
Bluebird.promisifyAll(network.constructor.prototype);
// promisify container
const container = docker.getContainer('promisify-container');
Bluebird.promisifyAll(container.constructor.prototype);
// promisify image
const image = docker.getImage('promisify-image');
Bluebird.promisifyAll(image.constructor.prototype);

export default docker;

;(async () => {
  const socketPath = SYSTEM.DOCKER_SOCKET
  const stats = fs.statSync(socketPath)

  if (!stats.isSocket()) {
    console.log('Docker can\'t connect.')
  }

  const docker = new DockerOde({
    socketPath: socketPath
  })

  const checkDockerEnv = async () => {
    try {
      const r = await docker.info()
      if (r.Architecture !== 'x86_64') {
        console.log('Require x86-64 system.')
      }
    } catch (err) {
      console.log('Please make sure Docker is working.')
    }

    try {
      const r = await docker.version()
      if (r.Version.split('.')[0] < 18) {

import Docker from 'dockerode';
import './lib/denodeify-proxy';
import pty from 'pty.js';
import express from 'express';
import http from 'http';
import server from 'socket.io';
import path from 'path';
import SocketStream from './lib/socketstream';
import dockerfile from './dockerfile';
import colors from 'ansi-256-colors';

const TAG = 'dockerweb:latest';

const docker = new Docker({socketPath: '/var/run/docker.sock'});

function formatId(value) {
  return value.slice(0, 12);
}

async function init() {
  const app = express();

  app.get('/docker', function (req, res) {
    res.sendFile(path.join(__dirname, '..', 'public', 'index.html'));
  });

  app.use('/', express.static(path.join(__dirname, '..', 'public')));

  console.log(`[INFO] Building ${ TAG }`);

import Docker from 'dockerode';
import { getContainer } from '../utils';

const docker = new Docker();

const stopContainer = ({ name }) => ({
  title: `Stopping ${name}`,
  task: async () => {
    const { Id: id, State: state } = await getContainer(name);
    const container = docker.getContainer(id);

    if (state === 'running') await container.stop();
    return container.remove();
  },
  skip: async () => {
    const container = await getContainer(name);
    if (!container) return 'Container does not exist';
    return false;
  },
});

constructor() {
    this.docker = new Docker();
  }

export function docker () {
  return new Docker()
}

function getDocker() {
  return new Docker()
}

"use strict";
import { exec } from "child_process";
import dockerode from "dockerode";
import path from "path";
import moment from "moment-timezone";
import * as processManager from "./processManager";
import { ProcessResult } from "./processManager";
import * as logger from "./logger";
import { ContainerStates } from "../projects/constants";
import { Stream } from "stream";
import { BuildRequest, ProjectInfo } from "../projects/Project";
import { StartModes } from "../projects/constants";
import * as logHelper from "../projects/logHelper";
import * as workspaceSettings from "./workspaceSettings";

const docker = new dockerode();

export interface ContainerInfo {
  containerId: string;
  ip: string;
  serviceName: string;
  exposedPort: string;
  internalPort: string;
  exposedDebugPort: string;
  internalDebugPort: string;
  containerPorts: string[];
  hostPorts: string[];
}

/**
 * @function
 * @description Get docker container information.