Docker Compose والـ Networks: الـ services بتلاقي بعض إزاي

// compose.js: بيحلل docker compose stack: مين يشوف مين على الـ network، وترتيب التشغيل، والمشاكل
const DEFAULT_PORTS = { postgres: 5432, postgresql: 5432, redis: 6379, mysql: 3306, http: 80, https: 443, amqp: 5672 };
const IMAGE_PORTS = { postgres: [5432], redis: [6379], mysql: [3306], mongo: [27017], nginx: [80], adminer: [8080], rabbitmq: [5672] };
const DATA_IMAGES = /^(postgres|redis|mysql|mongo|mariadb|rabbitmq)(:|$)/;

export const networksOf = (stack, name) => stack.services[name]?.networks ?? ["default"];

export function canReach(stack, from, to) {
  if (!stack.services[from] || !stack.services[to]) return false;
  const mine = new Set(networksOf(stack, from));
  return networksOf(stack, to).some((n) => mine.has(n));
}

export function parsePort(spec) {
  const [main, protocol = "tcp"] = String(spec).split("/");
  const parts = main.split(":");
  if (parts.length === 1) return { hostIp: null, host: null, container: Number(parts[0]), protocol };
  if (parts.length === 2) return { hostIp: "0.0.0.0", host: Number(parts[0]), container: Number(parts[1]), protocol };
  return { hostIp: parts[0], host: Number(parts[1]), container: Number(parts[2]), protocol };
}

export function containerPorts(svc) {
  const out = new Set([...(svc.ports ?? []).map((p) => parsePort(p).container), ...(svc.expose ?? []).map(Number)]);
  const img = /^([^:/]+)/.exec(svc.image ?? "")?.[1];
  for (const p of IMAGE_PORTS[img] ?? []) out.add(p);
  return [...out].sort((a, b) => a - b);
}

export function envUrls(svc) {
  const out = [];
  for (const [key, value] of Object.entries(svc.environment ?? {})) {
    let u;
    try { u = new URL(String(value)); } catch { continue; }
    if (!u.hostname) continue;
    const scheme = u.protocol.replace(":", "");
    out.push({ key, host: u.hostname, port: u.port ? Number(u.port) : DEFAULT_PORTS[scheme] ?? null });
  }
  return out;
}

const depsOf = (svc) => {
  const d = svc.depends_on ?? [];
  return Array.isArray(d) ? d.map((name) => ({ name, condition: "service_started" })) : Object.entries(d).map(([name, v]) => ({ name, condition: v?.condition ?? "service_started" }));
};

export function startOrder(stack) {
  const order = [], state = {};
  const visit = (n, path) => {
    if (state[n] === "done") return;
    if (state[n] === "doing") {
      const cycle = [...path.slice(path.indexOf(n)), n];
      throw Object.assign(new Error(`cycle: ${cycle.join(" → ")}`), { code: "CYCLE", path: cycle });
    }
    state[n] = "doing";
    for (const d of depsOf(stack.services[n]).map((x) => x.name).sort()) if (stack.services[d]) visit(d, [...path, n]);
    state[n] = "done";
    order.push(n);
  };
  for (const n of Object.keys(stack.services).sort()) visit(n, []);
  return order;
}

export function lintCompose(stack) {
  const out = [];
  const add = (rule, service, severity, msg) => out.push({ rule, service, severity, msg });
  const names = Object.keys(stack.services);

  for (const [name, svc] of Object.entries(stack.services)) {
 
…

$ node check.js stack.naive.js stack.js

===== stack.naive.js =====
  proxy   networks: default        يقدر يوصل لـ: api worker db redis admin
  api     networks: default        يقدر يوصل لـ: proxy worker db redis admin
  worker  networks: default        يقدر يوصل لـ: proxy api db redis admin
  db      networks: default        يقدر يوصل لـ: proxy api worker redis admin
  redis   networks: default        يقدر يوصل لـ: proxy api worker db admin
  admin   networks: default        يقدر يوصل لـ: proxy api worker db redis
  ترتيب التشغيل: مستحيل، cycle: db → worker → db
  ERROR LOCALHOST       api     DATABASE_URL: localhost جُوّه الـ container هو الـ container نفسه، استخدم اسم الـ service
  ERROR LOCALHOST       api     REDIS_URL: localhost جُوّه الـ container هو الـ container نفسه، استخدم اسم الـ service
  WARN  START-NOT-READY api     depends_on على db بيستنى الـ container يبدأ بس، مش الـ database تبقى جاهزة
  WARN  START-NOT-READY api     depends_on على redis بيستنى الـ container يبدأ بس، مش الـ database تبقى جاهزة
  ERROR UNKNOWN-HOST    worker  DATABASE_URL: مفيش service اسمها database
  WARN  WRONG-PORT      worker  API_URL: api مش بيسمع على 8080
  WARN  START-NOT-READY worker  de
…

// stack.naive.js: نفس compose.naive.yaml بالضبط، بس JS object علشان الـ tool بتاعتنا تقراه
export default {
  services: {
    proxy: { image: "nginx:1.27", ports: ["80:80"], depends_on: ["api"] },
    api: {
      build: ".",
      ports: ["3000:3000"],
      environment: { DATABASE_URL: "postgres://app:app@localhost:5432/app", REDIS_URL: "redis://localhost:6379" },
      depends_on: ["db", "redis"],
    },
    worker: {
      build: ".",
      command: ["node", "worker.js"],
      environment: { DATABASE_URL: "postgres://app:app@database:5432/app", API_URL: "http://api:8080" },
      depends_on: ["db"],
    },
    db: { image: "postgres:17", ports: ["5432:5432"], environment: { POSTGRES_PASSWORD: "app" }, depends_on: ["worker"] },
    redis: { image: "redis:7", ports: ["6379:6379"] },
    admin: { image: "adminer:4", ports: ["3000:8080"] },
  },
};

# compose.naive.yaml
services:
  proxy:
    image: "nginx:1.27"
    ports: ["80:80"]
    depends_on: ["api"]
  api:
    build: .
    ports: ["3000:3000"]
    environment:
      DATABASE_URL: "postgres://app:app@localhost:5432/app"
      REDIS_URL: "redis://localhost:6379"
    depends_on: ["db", "redis"]
  worker:
    build: .
    command: ["node", "worker.js"]
    environment:
      DATABASE_URL: "postgres://app:app@database:5432/app"
      API_URL: "http://api:8080"
    depends_on: ["db"]
  db:
    image: "postgres:17"
    ports: ["5432:5432"]
    environment:
      POSTGRES_PASSWORD: app
    depends_on: ["worker"]
  redis:
    image: "redis:7"
    ports: ["6379:6379"]
  admin:
    image: "adminer:4"
    ports: ["3000:8080"]

# compose.yaml
networks:
  edge: {}
  backend:
    internal: true
services:
  proxy:
    image: "nginx:1.27"
    ports: ["80:80"]
    networks: ["edge"]
    depends_on:
      api:
        condition: service_healthy
  api:
    build: .
    expose: ["3000"]
    networks: ["edge", "backend"]
    environment:
      DATABASE_URL: "postgres://app:app@db:5432/app"
      REDIS_URL: "redis://redis:6379"
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "node", "healthcheck.js"]
      interval: 5s
      retries: 5
  worker:
    build: .
    command: ["node", "worker.js"]
    networks: ["backend"]
    environment:
      DATABASE_URL: "postgres://app:app@db:5432/app"
      API_URL: "http://api:3000"
    depends_on:
      db:
        condition: service_healthy
  db:
    image: "postgres:17"
    networks: ["backend"]
    environment:
      POSTGRES_PASSWORD: app
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 2s
      retries: 10
  redis:
    image: "redis:7"
    networks: ["backend"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 2s
      retries: 10
  admin:
    image: "adminer:4"
    ports: ["127.0.0.1:8080:8080"]
    networks: ["edge", "backend"]
    depends_on:
      db:
        condition: service_healthy

// stack.js: نفس compose.yaml بالضبط، بس JS object علشان الـ tool بتاعتنا تقراه
export default {
  networks: { edge: {}, backend: { internal: true } },
  services: {
    proxy: { image: "nginx:1.27", ports: ["80:80"], networks: ["edge"], depends_on: { api: { condition: "service_healthy" } } },
    api: {
      build: ".",
      expose: ["3000"],
      networks: ["edge", "backend"],
      environment: { DATABASE_URL: "postgres://app:app@db:5432/app", REDIS_URL: "redis://redis:6379" },
      depends_on: { db: { condition: "service_healthy" }, redis: { condition: "service_healthy" } },
      healthcheck: { test: ["CMD", "node", "healthcheck.js"], interval: "5s", retries: 5 },
    },
    worker: {
      build: ".",
      command: ["node", "worker.js"],
      networks: ["backend"],
      environment: { DATABASE_URL: "postgres://app:app@db:5432/app", API_URL: "http://api:3000" },
      depends_on: { db: { condition: "service_healthy" } },
    },
    db: {
      image: "postgres:17",
      networks: ["backend"],
      environment: { POSTGRES_PASSWORD: "app" },
      healthcheck: { test: ["CMD-SHELL", "pg_isready -U postgres"], interval: "2s", retries: 10 },
    },
    redis: { image: "redis:7", networks: ["backend"], healthcheck: { test: ["CMD", "redis-cli", "ping"], interval: "2s", retries: 10 } },
    admin: { image: "adminer:4", ports: ["127.0.0.1:8080:8080"], networks: ["edge", "backend"], depends_on: { db: { condition: "service_healthy" } } },
  },
};

// check.js: بيحلل الـ stack: الـ networks، ومين يشوف مين، وترتيب التشغيل، والمشاكل
import { networksOf, canReach, startOrder, lintCompose } from "./compose.js";

for (const f of process.argv.slice(2)) {
  const stack = (await import(`./${f}`)).default;
  const names = Object.keys(stack.services);
  console.log(`\n===== ${f} =====`);
  for (const n of names) console.log(`  ${n.padEnd(7)} networks: ${networksOf(stack, n).join(", ").padEnd(14)} يقدر يوصل لـ: ${names.filter((m) => m !== n && canReach(stack, n, m)).join(" ") || "-"}`);
  try { console.log(`  ترتيب التشغيل: ${startOrder(stack).join(" → ")}`); } catch (e) { console.log(`  ترتيب التشغيل: مستحيل، ${e.message}`); }
  const found = lintCompose(stack);
  for (const x of found) console.log(`  ${x.severity.padEnd(5)} ${x.rule.padEnd(15)} ${x.service.padEnd(7)} ${x.msg}`);
  if (!found.length) console.log("  مفيش مشاكل");
}