@ongtrieuhau861457/runner-tailscale-sync 1.260202.11920

package/src/core/data-sync.js

@@ -0,0 +1,177 @@
+/**
+ * core/data-sync.js
+ * Pull/Push .runner-data directory giữa các runners
+ */
+
+const path = require("path");
+const fs_adapter = require("../adapters/fs");
+const process_adapter = require("../adapters/process");
+const { SyncError, ValidationError } = require("../utils/errors");
+const CONST = require("../utils/constants");
+
+/**
+ * Parse input
+ */
+function parseInput(config, previousRunner, logger) {
+  return {
+    localDataDir: config.runnerDataDir,
+    remoteHost: previousRunner?.dnsName || previousRunner?.ips?.[0],
+    remoteDataDir: config.runnerDataDir,
+    rsyncPath: config.rsyncPath,
+    sshPath: config.sshPath,
+    logger,
+  };
+}
+
+/**
+ * Validate
+ */
+function validate(input) {
+  const errors = [];
+
+  if (!input.localDataDir) {
+    errors.push("Local data directory is required");
+  }
+
+  if (!input.remoteHost) {
+    errors.push("Remote host is required");
+  }
+
+  if (errors.length > 0) {
+    throw new ValidationError(`Validation failed: ${errors.join(", ")}`);
+  }
+}
+
+/**
+ * Plan
+ */
+function plan(input) {
+  return {
+    action: "rsync_pull",
+    source: `${input.remoteHost}:${input.remoteDataDir}/`,
+    destination: input.localDataDir,
+    rsyncPath: input.rsyncPath,
+    sshPath: input.sshPath,
+  };
+}
+
+/**
+ * Execute - pull data từ remote runner
+ */
+async function execute(planResult, input) {
+  const { logger } = input;
+
+  logger.info(`Syncing data from ${planResult.source}...`);
+
+  // Ensure local directory exists
+  fs_adapter.ensureDir(planResult.destination);
+
+  // Build rsync command
+  // rsync -avz -e ssh remote:.runner-data/ local/.runner-data/
+  const isLocalNetwork = input.remoteHost?.startsWith("100.");
+  const rsyncCmd = [
+    planResult.rsyncPath,
+    isLocalNetwork ? "-av" : "-avz",
+    "--delete",
+    "--partial",
+    "--progress",
+    "-e",
+    `${planResult.sshPath} -o StrictHostKeyChecking=no`,
+    planResult.source,
+    planResult.destination,
+  ];
+
+  try {
+    await process_adapter.runWithTimeout(
+      rsyncCmd,
+      CONST.RSYNC_TIMEOUT,
+      { logger }
+    );
+
+    logger.success("Data synced successfully");
+
+    // Get synced size
+    const size = fs_adapter.getDirSize(planResult.destination);
+    logger.info(`Synced size: ${fs_adapter.formatBytes(size)}`);
+
+    return {
+      success: true,
+      size,
+    };
+  } catch (err) {
+    // If rsync not available, try scp as fallback
+    logger.warn("Rsync failed, trying scp as fallback...");
+
+    try {
+      const scpCmd = `${planResult.sshPath} -r ${planResult.source} ${planResult.destination}`;
+      await process_adapter.runWithTimeout(
+        scpCmd,
+        CONST.RSYNC_TIMEOUT,
+        { logger }
+      );
+
+      logger.success("Data synced via scp");
+      const size = fs_adapter.getDirSize(planResult.destination);
+      return {
+        success: true,
+        size,
+      };
+    } catch (scpErr) {
+      throw new SyncError(`Failed to sync data: ${scpErr.message}`);
+    }
+  }
+}
+
+/**
+ * Report
+ */
+function report(result, input) {
+  const { logger } = input;
+
+  if (result.success) {
+    logger.success("Data synchronization completed");
+    return {
+      success: true,
+      syncedSize: result.size,
+    };
+  } else {
+    logger.error("Data synchronization failed");
+    return {
+      success: false,
+    };
+  }
+}
+
+/**
+ * Main pull function
+ */
+async function pullData(config, previousRunner, logger) {
+  if (!previousRunner) {
+    logger.info("No previous runner - skipping data pull");
+    return { success: true, syncedSize: 0 };
+  }
+
+  // Step 1: Parse Input
+  const input = parseInput(config, previousRunner, logger);
+
+  // Step 2: Validate
+  validate(input);
+
+  // Step 3: Plan
+  const planResult = plan(input);
+
+  // Step 4: Execute
+  const execResult = await execute(planResult, input);
+
+  // Step 5: Report
+  return report(execResult, input);
+}
+
+module.exports = {
+  pullData,
+  parseInput,
+  validate,
+  plan,
+  execute,
+  report,
+};

package/src/core/init.js

@@ -0,0 +1,141 @@
+/**
+ * core/init.js
+ * Initialize Tailscale and detect previous runner
+ */
+
+const tailscale = require("../adapters/tailscale");
+const fs_adapter = require("../adapters/fs");
+const runnerDetector = require("./runner-detector");
+const { ValidationError, ProcessError } = require("../utils/errors");
+
+/**
+ * Parse input
+ */
+function parseInput(config, logger) {
+  return {
+    config,
+    logger,
+  };
+}
+
+/**
+ * Validate
+ */
+function validate(input) {
+  const errors = input.config.validate();
+  if (errors.length > 0) {
+    throw new ValidationError(`Validation failed:\n  - ${errors.join("\n  - ")}`);
+  }
+}
+
+/**
+ * Plan
+ */
+function plan(input) {
+  const { config } = input;
+
+  return {
+    steps: [
+      { name: "setup_directories", enabled: true },
+      { name: "connect_tailscale", enabled: config.tailscaleEnable },
+      { name: "detect_previous_runner", enabled: config.tailscaleEnable },
+    ],
+  };
+}
+
+/**
+ * Execute
+ */
+async function execute(planResult, input) {
+  const { config, logger } = input;
+  const results = {};
+
+  for (const step of planResult.steps) {
+    if (!step.enabled) {
+      logger.debug(`Skipping step: ${step.name}`);
+      continue;
+    }
+
+    logger.info(`━━━ Step: ${step.name} ━━━`);
+
+    switch (step.name) {
+      case "setup_directories": {
+        const dirs = config.getDirectoriesToEnsure();
+        fs_adapter.ensureDirs(dirs);
+        logger.success(`Created ${dirs.length} directories`);
+        results.setupDirs = dirs;
+        break;
+      }
+      case "connect_tailscale": {
+        const installed = tailscale.install(logger);
+        if (!installed) {
+          throw new ProcessError("Failed to install Tailscale");
+        }
+
+        await tailscale.login(
+          config.tailscaleClientId,
+          config.tailscaleClientSecret,
+          config.tailscaleTags,
+          logger,
+          config
+        );
+
+        const ip = tailscale.getIP(logger);
+        const hostname = tailscale.getHostname(logger);
+        logger.success(`Tailscale connected: ${ip || hostname}`);
+        results.tailscale = { ip, hostname };
+        break;
+      }
+      case "detect_previous_runner": {
+        results.detection = await runnerDetector.detectPreviousRunner(config, logger);
+        if (results.detection.previousRunner) {
+          logger.success(`Previous runner: ${results.detection.previousRunner.hostname}`);
+          logger.info(`  IP: ${results.detection.previousRunner.ips[0]}`);
+        } else {
+          logger.info("No previous runner found - this is the first runner");
+        }
+        break;
+      }
+      default:
+        logger.warn(`Unknown step: ${step.name}`);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Report
+ */
+function report(results, input) {
+  const { logger } = input;
+  if (!input.config.tailscaleEnable) {
+    logger.info("Tailscale disabled - skipping network setup");
+  }
+  logger.success("Init workflow completed");
+  return {
+    success: true,
+    tailscale: results.tailscale,
+    previousRunner: results.detection?.previousRunner || null,
+  };
+}
+
+/**
+ * Main init function
+ */
+async function initRunner(config, logger) {
+  const input = parseInput(config, logger);
+  validate(input);
+  const planResult = plan(input);
+  const execResult = await execute(planResult, input);
+  return report(execResult, input);
+}
+
+module.exports = {
+  initRunner,
+  parseInput,
+  validate,
+  plan,
+  execute,
+  report,
+};

package/src/core/push.js

@@ -0,0 +1,113 @@
+/**
+ * core/push.js
+ * Push .runner-data to git repository
+ */
+
+const git = require("../adapters/git");
+const { getTimestamp } = require("../utils/time");
+const { ValidationError, ProcessError } = require("../utils/errors");
+
+/**
+ * Parse input
+ */
+function parseInput(config, logger) {
+  return {
+    gitEnabled: config.gitEnabled,
+    gitBranch: config.gitBranch,
+    cwd: config.cwd,
+    logger,
+  };
+}
+
+/**
+ * Validate
+ */
+function validate(input) {
+  if (!input.gitEnabled) {
+    return;
+  }
+
+  if (!git.isAvailable()) {
+    throw new ProcessError("Git is not available");
+  }
+
+  if (!git.isGitRepo(input.cwd)) {
+    throw new ValidationError("Not a git repository");
+  }
+}
+
+/**
+ * Plan
+ */
+function plan(input) {
+  if (!input.gitEnabled) {
+    return { action: "skip" };
+  }
+
+  return {
+    action: "push_runner_data",
+    branch: input.gitBranch,
+    cwd: input.cwd,
+  };
+}
+
+/**
+ * Execute
+ */
+async function execute(planResult, input) {
+  const { logger } = input;
+
+  if (planResult.action === "skip") {
+    logger.warn("Git push disabled (GIT_PUSH_ENABLED=0)");
+    return { skipped: true };
+  }
+
+  const timestamp = getTimestamp();
+  const message = `[runner-sync] Update .runner-data at ${timestamp}`;
+
+  const pushed = await git.commitAndPush(message, planResult.branch, {
+    logger,
+    cwd: planResult.cwd,
+  });
+
+  return { pushed };
+}
+
+/**
+ * Report
+ */
+function report(result, input) {
+  const { logger } = input;
+
+  if (result.skipped) {
+    return { success: false, skipped: true };
+  }
+
+  if (result.pushed) {
+    logger.success("Pushed to git repository");
+    return { success: true };
+  }
+
+  logger.info("No changes to push");
+  return { success: true, noChanges: true };
+}
+
+/**
+ * Main push function
+ */
+async function pushRunnerData(config, logger) {
+  const input = parseInput(config, logger);
+  validate(input);
+  const planResult = plan(input);
+  const execResult = await execute(planResult, input);
+  return report(execResult, input);
+}
+
+module.exports = {
+  pushRunnerData,
+  parseInput,
+  validate,
+  plan,
+  execute,
+  report,
+};

package/src/core/runner-detector.js

@@ -0,0 +1,167 @@
+/**
+ * core/runner-detector.js
+ * Phát hiện runner trước đó trên Tailscale network
+ */
+
+const tailscale = require("../adapters/tailscale");
+const ssh = require("../adapters/ssh");
+const { ValidationError } = require("../utils/errors");
+
+/**
+ * Parse input
+ */
+function parseInput(config, logger) {
+  return {
+    tags: String(config.tailscaleTags || "").split(",").map(s=>s.trim()).filter(Boolean),
+    sshPath: config.sshPath,
+    logger,
+  };
+}
+
+/**
+ * Validate
+ */
+function validate(input) {
+  const errors = [];
+
+  if (!input.tags || input.tags.length === 0) {
+    errors.push("Tailscale tag is required");
+  }
+
+  if (errors.length > 0) {
+    throw new ValidationError(`Validation failed: ${errors.join(", ")}`);
+  }
+}
+
+/**
+ * Plan - xác định strategy
+ */
+function plan(input) {
+  return {
+    action: "detect_previous_runner",
+    tags: input.tags,
+  };
+}
+
+/**
+ * Execute - tìm runner trước đó
+ */
+async function execute(planResult, input) {
+  const { logger } = input;
+
+  logger.info("Searching for previous runner on Tailscale network...");
+
+  // Get all peers with same tag
+  const peers = tailscale.findPeersWithTag(planResult.tags, logger);
+
+  if (peers.length === 0) {
+    logger.info("No previous runner found");
+    return {
+      found: false,
+      peer: null,
+    };
+  }
+
+  for (const peer of peers) {
+    const targetHost = peer.ips?.[0];
+    if (!targetHost) {
+      peer.accessible = false;
+      continue;
+    }
+    peer.accessible = await Promise.resolve(
+      ssh.checkConnection(targetHost, { logger, sshPath: input.sshPath })
+    );
+  }
+
+  const accessiblePeers = peers.filter((peer) => peer.accessible);
+
+  for (const peer of accessiblePeers) {
+    const targetHost = peer.ips?.[0];
+    if (!targetHost) {
+      peer.hasData = false;
+      continue;
+    }
+    const result = ssh.executeCommandCapture(
+      targetHost,
+      'test -d .runner-data && echo "yes"',
+      { sshPath: input.sshPath }
+    );
+    peer.hasData = result === "yes";
+  }
+
+  const peer = accessiblePeers
+    .filter((item) => item.hasData)
+    .slice()
+    .sort((a, b) => {
+      const ta = a.lastSeen ? Date.parse(a.lastSeen) : 0;
+      const tb = b.lastSeen ? Date.parse(b.lastSeen) : 0;
+      return tb - ta;
+    })[0];
+
+  if (!peer) {
+    logger.info("No accessible runner with data found");
+    return {
+      found: false,
+      peer: null,
+    };
+  }
+
+  logger.success(`Found previous runner: ${peer.hostname || peer.id}`);
+  logger.info(`  IP: ${peer.ips[0] || "N/A"}`);
+  logger.info(`  DNS: ${peer.dnsName || "N/A"}`);
+
+  return {
+    found: true,
+    peer,
+  };
+}
+
+/**
+ * Report
+ */
+function report(result, input) {
+  const { logger } = input;
+
+  if (result.found) {
+    logger.success("Previous runner detected");
+    return {
+      success: true,
+      previousRunner: result.peer,
+    };
+  } else {
+    logger.info("No previous runner - this is the first runner");
+    return {
+      success: true,
+      previousRunner: null,
+    };
+  }
+}
+
+/**
+ * Main detect function
+ */
+async function detectPreviousRunner(config, logger) {
+  // Step 1: Parse Input
+  const input = parseInput(config, logger);
+
+  // Step 2: Validate
+  validate(input);
+
+  // Step 3: Plan
+  const planResult = plan(input);
+
+  // Step 4: Execute
+  const execResult = await execute(planResult, input);
+
+  // Step 5: Report
+  return report(execResult, input);
+}
+
+module.exports = {
+  detectPreviousRunner,
+  parseInput,
+  validate,
+  plan,
+  execute,
+  report,
+};