@serve.zone/gitops 2.13.1

package/ts/classes/jobmanager.ts

@@ -0,0 +1,337 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logging.js';
+import { intervalMinutesToMs, unrefTimer, validateIntervalMinutes } from '../timers.js';
+import type * as interfaces from '../../ts_interfaces/index.js';
+import type { ConnectionManager } from './connectionmanager.js';
+import type { ActionLog } from './actionlog.js';
+import type { StorageManager } from '../storage/index.js';
+import { getRunner, type IJobRunContext } from './jobrunners/index.js';
+
+const JOBS_PREFIX = '/jobs/';
+const KEYCHAIN_PREFIX = 'keychain:';
+const KEYCHAIN_JOB_PREFIX = 'gitops-job-';
+
+/**
+ * Manages job configurations: CRUD, scheduling, and execution dispatch.
+ * Job-type-specific logic is delegated to registered runners.
+ */
+export class JobManager {
+  private jobs: interfaces.data.IJobConfig[] = [];
+  private timers: Map<string, ReturnType<typeof setInterval>> = new Map();
+  private runningJobs: Set<string> = new Set();
+  private activeJobExecutions = new Set<Promise<void>>();
+  private stopping = false;
+
+  constructor(
+    private storageManager: StorageManager,
+    private connectionManager: ConnectionManager,
+    private actionLog: ActionLog,
+    private smartSecret: plugins.smartsecret.SmartSecret,
+  ) {}
+
+  async init(): Promise<void> {
+    this.stopping = false;
+    await this.loadJobs();
+    for (const job of this.jobs) {
+      if (job.status === 'active') {
+        this.startTimer(job);
+      }
+    }
+    if (this.jobs.length > 0) {
+      logger.info(`JobManager loaded ${this.jobs.length} job(s)`);
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.stopping = true;
+    for (const [_id, timer] of this.timers) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+
+    if (this.activeJobExecutions.size > 0) {
+      logger.info(`Waiting for ${this.activeJobExecutions.size} active job execution(s) to finish...`);
+      await Promise.allSettled([...this.activeJobExecutions]);
+    }
+  }
+
+  // ============================================================================
+  // CRUD
+  // ============================================================================
+
+  getJobs(): interfaces.data.IJobConfig[] {
+    return this.jobs.map((j) => this.maskSecrets(j));
+  }
+
+  getJob(id: string): interfaces.data.IJobConfig | undefined {
+    const job = this.jobs.find((j) => j.id === id);
+    return job ? this.maskSecrets(job) : undefined;
+  }
+
+  async createJob(data: {
+    name: string;
+    jobType: interfaces.data.TJobType;
+    intervalMinutes: number;
+    autoBookstackDocsConfig?: interfaces.data.IAutoBookstackDocsConfig;
+  }): Promise<interfaces.data.IJobConfig> {
+    // Validate that a runner exists for this job type
+    getRunner(data.jobType);
+
+    const now = Date.now();
+    const intervalMinutes = validateIntervalMinutes(data.intervalMinutes, 'job intervalMinutes');
+    const job: interfaces.data.IJobConfig = {
+      id: crypto.randomUUID(),
+      name: data.name,
+      jobType: data.jobType,
+      status: 'paused',
+      intervalMinutes,
+      lastRunAt: 0,
+      createdAt: now,
+      updatedAt: now,
+      autoBookstackDocsConfig: data.autoBookstackDocsConfig,
+    };
+
+    // Store BookStack token in keychain
+    if (job.autoBookstackDocsConfig) {
+      await this.storeBookstackToken(job.id, job.autoBookstackDocsConfig.bookstackTarget.tokenSecret);
+      job.autoBookstackDocsConfig.bookstackTarget.tokenSecret = `${KEYCHAIN_PREFIX}${KEYCHAIN_JOB_PREFIX}${job.id}`;
+    }
+
+    this.jobs.push(job);
+    await this.persistJob(job);
+    logger.success(`Job created: ${job.name} (${job.jobType})`);
+    return this.maskSecrets(job);
+  }
+
+  async updateJob(
+    id: string,
+    updates: {
+      name?: string;
+      intervalMinutes?: number;
+      autoBookstackDocsConfig?: interfaces.data.IAutoBookstackDocsConfig;
+    },
+  ): Promise<interfaces.data.IJobConfig> {
+    const job = this.jobs.find((j) => j.id === id);
+    if (!job) throw new Error(`Job not found: ${id}`);
+
+    if (updates.name !== undefined) job.name = updates.name;
+    if (updates.intervalMinutes !== undefined) {
+      job.intervalMinutes = validateIntervalMinutes(updates.intervalMinutes, 'job intervalMinutes');
+    }
+    if (updates.autoBookstackDocsConfig !== undefined) {
+      const newToken = updates.autoBookstackDocsConfig.bookstackTarget.tokenSecret;
+      if (newToken && newToken !== '***' && !newToken.startsWith(KEYCHAIN_PREFIX)) {
+        // New real token provided — store in keychain
+        await this.storeBookstackToken(job.id, newToken);
+        updates.autoBookstackDocsConfig.bookstackTarget.tokenSecret = `${KEYCHAIN_PREFIX}${KEYCHAIN_JOB_PREFIX}${job.id}`;
+      } else {
+        // Empty, masked, or sentinel — preserve existing token reference
+        const existingToken = job.autoBookstackDocsConfig?.bookstackTarget?.tokenSecret;
+        if (existingToken) {
+          updates.autoBookstackDocsConfig.bookstackTarget.tokenSecret = existingToken;
+        }
+      }
+      job.autoBookstackDocsConfig = updates.autoBookstackDocsConfig;
+    }
+    job.updatedAt = Date.now();
+
+    await this.persistJob(job);
+
+    // Restart timer if active
+    if (job.status === 'active') {
+      this.stopTimer(job.id);
+      this.startTimer(job);
+    }
+
+    return this.maskSecrets(job);
+  }
+
+  async deleteJob(id: string): Promise<void> {
+    const idx = this.jobs.findIndex((j) => j.id === id);
+    if (idx === -1) throw new Error(`Job not found: ${id}`);
+    this.stopTimer(id);
+    this.jobs.splice(idx, 1);
+    await this.storageManager.delete(`${JOBS_PREFIX}${id}.json`);
+    await this.smartSecret.deleteSecret(`${KEYCHAIN_JOB_PREFIX}${id}`);
+    logger.info(`Job deleted: ${id}`);
+  }
+
+  async pauseJob(id: string, paused: boolean): Promise<interfaces.data.IJobConfig> {
+    const job = this.jobs.find((j) => j.id === id);
+    if (!job) throw new Error(`Job not found: ${id}`);
+    job.status = paused ? 'paused' : 'active';
+    job.updatedAt = Date.now();
+    if (paused) {
+      this.stopTimer(id);
+    } else {
+      this.startTimer(job);
+    }
+    await this.persistJob(job);
+    logger.info(`Job ${paused ? 'paused' : 'resumed'}: ${job.name}`);
+    return this.maskSecrets(job);
+  }
+
+  // ============================================================================
+  // Execution
+  // ============================================================================
+
+  async executeJob(jobId: string, force = false): Promise<void> {
+    if (this.stopping) {
+      logger.warn(`JobManager is stopping, skipping job ${jobId}`);
+      return;
+    }
+
+    const executionPromise = this.executeJobInternal(jobId, force);
+    this.activeJobExecutions.add(executionPromise);
+    try {
+      await executionPromise;
+    } finally {
+      this.activeJobExecutions.delete(executionPromise);
+    }
+  }
+
+  private async executeJobInternal(jobId: string, force = false): Promise<void> {
+    const job = this.jobs.find((j) => j.id === jobId);
+    if (!job) throw new Error(`Job not found: ${jobId}`);
+
+    if (this.runningJobs.has(jobId)) {
+      logger.warn(`Job "${job.name}" is already running, skipping`);
+      return;
+    }
+
+    if (!force && job.status !== 'active') {
+      logger.warn(`Job "${job.name}" is not active, skipping`);
+      return;
+    }
+
+    this.runningJobs.add(jobId);
+    const startTime = Date.now();
+
+    try {
+      const runner = getRunner(job.jobType);
+      const context: IJobRunContext = {
+        jobConfig: job,
+        connectionManager: this.connectionManager,
+        storageManager: this.storageManager,
+        smartSecret: this.smartSecret,
+      };
+
+      logger.jobLog('info', `Executing job: ${job.name}`, 'job');
+      await runner.execute(context);
+
+      const durationSec = ((Date.now() - startTime) / 1000).toFixed(1);
+      job.lastRunAt = startTime;
+      job.lastRunDurationMs = Date.now() - startTime;
+      job.lastRunError = undefined;
+      if (job.status === 'error') job.status = 'active';
+      logger.jobLog('success', `Job "${job.name}" completed in ${durationSec}s`, 'job');
+    } catch (err) {
+      job.lastRunAt = startTime;
+      job.lastRunDurationMs = Date.now() - startTime;
+      job.lastRunError = String(err);
+      job.status = 'error';
+      logger.jobLog('error', `Job "${job.name}" failed: ${err}`, 'job');
+    } finally {
+      job.updatedAt = Date.now();
+      this.runningJobs.delete(jobId);
+      await this.persistJob(job);
+    }
+  }
+
+  isJobRunning(jobId: string): boolean {
+    return this.runningJobs.has(jobId);
+  }
+
+  // ============================================================================
+  // Storage
+  // ============================================================================
+
+  private async loadJobs(): Promise<void> {
+    const keys = await this.storageManager.list(JOBS_PREFIX);
+    this.jobs = [];
+    for (const key of keys) {
+      const job = await this.storageManager.getJSON<interfaces.data.IJobConfig>(key);
+      if (job) {
+        try {
+          job.intervalMinutes = validateIntervalMinutes(job.intervalMinutes, `job "${job.name}" intervalMinutes`);
+        } catch (err) {
+          job.status = 'error';
+          job.lastRunError = err instanceof Error ? err.message : String(err);
+          job.updatedAt = Date.now();
+          await this.persistJob(job);
+        }
+
+        // Resolve keychain sentinels for BookStack tokens
+        if (job.autoBookstackDocsConfig) {
+          const token = job.autoBookstackDocsConfig.bookstackTarget.tokenSecret;
+          if (token.startsWith(KEYCHAIN_PREFIX)) {
+            const keychainId = token.slice(KEYCHAIN_PREFIX.length);
+            const realToken = await this.smartSecret.getSecret(keychainId);
+            if (realToken) {
+              job.autoBookstackDocsConfig.bookstackTarget.tokenSecret = realToken;
+            } else {
+              logger.warn(`Could not retrieve BookStack token for job ${job.id} from keychain`);
+            }
+          }
+        }
+        this.jobs.push(job);
+      }
+    }
+  }
+
+  private async persistJob(job: interfaces.data.IJobConfig): Promise<void> {
+    // Create a copy with token replaced by sentinel for storage
+    const stored = structuredClone(job);
+    if (stored.autoBookstackDocsConfig) {
+      const token = stored.autoBookstackDocsConfig.bookstackTarget.tokenSecret;
+      if (token && !token.startsWith(KEYCHAIN_PREFIX)) {
+        await this.storeBookstackToken(job.id, token);
+        stored.autoBookstackDocsConfig.bookstackTarget.tokenSecret = `${KEYCHAIN_PREFIX}${KEYCHAIN_JOB_PREFIX}${job.id}`;
+      }
+    }
+    await this.storageManager.setJSON(`${JOBS_PREFIX}${job.id}.json`, stored);
+  }
+
+  private async storeBookstackToken(jobId: string, tokenSecret: string): Promise<void> {
+    await this.smartSecret.setSecret(`${KEYCHAIN_JOB_PREFIX}${jobId}`, tokenSecret);
+  }
+
+  private maskSecrets(job: interfaces.data.IJobConfig): interfaces.data.IJobConfig {
+    const masked = structuredClone(job);
+    if (masked.autoBookstackDocsConfig) {
+      masked.autoBookstackDocsConfig.bookstackTarget.tokenSecret = '***';
+    }
+    return masked;
+  }
+
+  // ============================================================================
+  // Timers
+  // ============================================================================
+
+  private startTimer(job: interfaces.data.IJobConfig): void {
+    if (this.timers.has(job.id)) return;
+    let intervalMs: number;
+    try {
+      intervalMs = intervalMinutesToMs(job.intervalMinutes, `job "${job.name}" intervalMinutes`);
+    } catch (err) {
+      logger.error(`Timer not started for job "${job.name}": ${err}`);
+      return;
+    }
+    const timer = setInterval(() => {
+      this.executeJob(job.id).catch((err) => {
+        logger.error(`Timer-triggered job execution failed for "${job.name}": ${err}`);
+      });
+    }, intervalMs);
+    unrefTimer(timer);
+    this.timers.set(job.id, timer);
+    logger.info(`Timer started for job "${job.name}" (every ${job.intervalMinutes}min)`);
+  }
+
+  private stopTimer(jobId: string): void {
+    const timer = this.timers.get(jobId);
+    if (timer !== undefined) {
+      clearInterval(timer);
+      this.timers.delete(jobId);
+    }
+  }
+}