containerManager.js

const Docker = require("dockerode");
const docker = new Docker();

const containerUsage = {};
const containerIndex = {};
const inProgressContainers = {};

const MAX_USAGE_PER_CONTAINER = 20;
const MAX_CONTAINERS_PER_LANGUAGE = 10;
const IDLE_TIME_LIMIT = 3 * 60 * 1000;

const languages = {
  python: {
    image: "python:3.9",
    extension: "py",
    command: "python3 /code/Main.py",
    interpreted: true,
    memory: 256 * 1024 * 1024, cpu: 256
  },
  javascript: {
    image: "node:18",
    extension: "js",
    command: "node /code/Main.js",
    interpreted: true,
    memory: 512 * 1024 * 1024, cpu: 512
  },
  java: {
    image: "openjdk:17",
    extension: "java",
    compileCmd: "[ -f /code/Main.class ] || javac /code/Main.java",
    runCmd: "java -cp /code Main",
    interpreted: false,
    memory: 1024 * 1024 * 1024, cpu: 1024
  },
  cpp: {
    image: "gcc:latest",
    extension: "cpp",
    compileCmd: "[ -f /code/main ] || g++ /code/Main.cpp -o /code/main",
    runCmd: "/code/main",
    interpreted: false,
    memory: 1024 * 1024 * 1024, cpu: 1024
  },
};

async function getContainer(language) {
  if (!containerUsage[language]) containerUsage[language] = {};

  const containers = await docker.listContainers({ all: true });
  const activeContainers = containers.filter((c) => c.Image === languages[language].image);

  if (activeContainers.length < MAX_CONTAINERS_PER_LANGUAGE) {
    return createNewContainer(language);
  }

  const leastUsedContainer = activeContainers.reduce((prev, curr) => {
    if (containerUsage[language][curr.Id] < containerUsage[language][prev.Id]) return curr;
    return prev;
  });

  if (containerUsage[language][leastUsedContainer.Id] < MAX_USAGE_PER_CONTAINER) {
    containerUsage[language][leastUsedContainer.Id]++;
    return docker.getContainer(leastUsedContainer.Id);
  }

  const leastUsedIndex = containerIndex[language] || 0;
  const nextIndex = (leastUsedIndex + 1) % activeContainers.length;
  containerIndex[language] = nextIndex;

  const nextContainer = docker.getContainer(activeContainers[nextIndex].Id);
  containerUsage[language][nextContainer.id]++;
  return nextContainer;
}

async function releaseContainer(language, containerId) {
  if (containerUsage[language] && containerUsage[language][containerId]) {
    containerUsage[language][containerId]--;
    console.log(`Released container ${containerId} for ${language}`);
  }
}

async function createNewContainer(language) {
  if (inProgressContainers[language]) return await inProgressContainers[language];

  inProgressContainers[language] = (async () => {
    try {
      const { image, memory, cpu } = languages[language];

      const container = await docker.createContainer({
        Image: image,
        Tty: false,
        AttachStdout: true,
        AttachStderr: true,
        OpenStdin: true,
        HostConfig: {
          Binds: ["/tmp/compiler:/code"],
          Memory: memory,
          CpuShares: cpu,
          RestartPolicy: {
            Name: "on-failure",
            MaximumRetryCount: 2,
          },
        },
      });

      await container.start();
      containerUsage[language][container.id] = 1;
      return container;
    } finally {
      delete inProgressContainers[language];
    }
  })();

  return inProgressContainers[language];
}

async function cleanUpContainers() {
  try {
    const now = Date.now();

    const remoteContainers = await docker.listContainers({ all: true });
    const stoppedContainers = remoteContainers.filter((c) => c.State !== "running");

    await Promise.allSettled(
      stoppedContainers.map(async (c) => {
        const container = docker.getContainer(c.Id);
        await container.remove();
      })
    );

    const runningContainers = remoteContainers.filter((c) => c.State === "running");

    await Promise.allSettled(
      runningContainers.map(async (c) => {
        const container = docker.getContainer(c.Id);
        try {
          const { State } = await container.inspect();
          const lastStarted = new Date(State.StartedAt).getTime();
          const idleTime = now - lastStarted;

          const stats = await container.stats({ stream: false });
          const cpuDelta = stats.cpu_stats.cpu_usage.total_usage - stats.precpu_stats.cpu_usage.total_usage;
          const systemDelta = stats.cpu_stats.system_cpu_usage - stats.precpu_stats.system_cpu_usage;
          const cpuPercent = (cpuDelta / systemDelta) * stats.cpu_stats.cpu_usage.percpu_usage.length * 100;

          if (cpuPercent > 0 || idleTime < IDLE_TIME_LIMIT) return;

          await container.stop();
          await container.remove();
        } catch (err) {
          console.warn(`Error processing ${c.Id}: ${err.message}`);
        }
      })
    );
  } catch (error) {
    console.error("Cleanup failed:", error);
  }
}

setInterval(cleanUpContainers, 2 * 60 * 1000);

module.exports = {
  getContainer,
  languages,
  docker,
  releaseContainer,
};