@mtakla/cronops 0.1.1-rc6 → 0.1.1

package/dist/api/openapi.js

@@ -9,6 +9,84 @@ export const openapi = {
                 bearerFormat: "hex-256",
             },
         },
+        parameters: {
+            JobId: {
+                name: "jobId",
+                in: "path",
+                required: true,
+                schema: { type: "string" },
+            },
+        },
+        schemas: {
+            Job: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    id: { type: "string", example: "example-job" },
+                    cron: { type: "string", minLength: 1, example: "*/5 * * * *" },
+                    action: {
+                        type: "string",
+                        enum: ["exec", "call", "copy", "move", "delete", "archive"],
+                        example: "copy",
+                    },
+                    command: { type: "string" },
+                    shell: {
+                        anyOf: [{ type: "boolean" }, { type: "string", minLength: 1 }],
+                    },
+                    args: {
+                        type: "array",
+                        items: { type: "string", minLength: 1 },
+                        minItems: 1,
+                    },
+                    env: {
+                        type: "object",
+                        propertyNames: {
+                            type: "string",
+                            pattern: "^[A-Z_][A-Z0-9_]*$",
+                        },
+                        additionalProperties: { type: "string" },
+                    },
+                    source: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            dir: { type: "string", minLength: 1 },
+                            includes: {
+                                type: "array",
+                                items: { type: "string", minLength: 1 },
+                                minItems: 1,
+                            },
+                            excludes: {
+                                type: "array",
+                                items: { type: "string", minLength: 1 },
+                                minItems: 1,
+                            },
+                        },
+                    },
+                    target: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            dir: { type: "string", minLength: 1 },
+                            archive_name: { type: "string", minLength: 1 },
+                            permissions: {
+                                type: "object",
+                                additionalProperties: false,
+                                properties: {
+                                    owner: { type: "string", minLength: 1 },
+                                    file_mode: { type: "string", minLength: 1 },
+                                    dir_mode: { type: "string", minLength: 1 },
+                                },
+                            },
+                            retention: { type: "string", minLength: 1 },
+                        },
+                    },
+                    dry_run: { type: "boolean" },
+                    verbose: { type: "boolean" },
+                    enabled: { type: "boolean" },
+                },
+            },
+        },
     },
     tags: [
         {
@@ -17,19 +95,11 @@ export const openapi = {
         },
         {
             name: "jobs",
-            description: "CronOps job related tasks",
+            description: "job related api",
         },
         {
-            name: "admin",
-            description: "CronOps admin tasks",
-        },
-        {
-            name: "user",
-            description: "Operations about user",
-            externalDocs: {
-                description: "Find out more about our store",
-                url: "http://swagger.io",
-            },
+            name: "schedule",
+            description: "scheduling api",
         },
     ],
     paths: {
@@ -84,18 +154,69 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/trigger/{jobId}": {
+        "/api/jobs": {
+            get: {
+                summary: "Get jobs",
+                tags: ["jobs"],
+                responses: {
+                    "200": {
+                        description: "Array of scheduled jobs",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "array",
+                                    items: { $ref: "#/components/schemas/Job" },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/api/jobs/{jobId}": {
+            get: {
+                summary: "Get a job",
+                tags: ["jobs"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
+                responses: {
+                    "200": {
+                        description: "Array of scheduled jobs",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/Job" },
+                            },
+                        },
+                    },
+                    "404": {
+                        description: "Job not found",
+                    },
+                },
+            },
+        },
+        "/api/status": {
+            get: {
+                summary: "Get status",
+                tags: ["schedule"],
+                responses: {
+                    "200": {
+                        description: "Array of scheduled jobs",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "array",
+                                    items: { $ref: "#/components/schemas/Job" },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "/api/trigger/{jobId}": {
             post: {
                 summary: "Trigger a job",
-                tags: ["jobs"],
-                parameters: [
-                    {
-                        name: "jobId",
-                        in: "path",
-                        required: true,
-                        schema: { type: "string" },
-                    },
-                ],
+                tags: ["schedule"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
                 responses: {
                     "200": {
                         description: "Triggered",
@@ -118,18 +239,10 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/pause/{jobId}": {
+        "/api/pause": {
             post: {
-                summary: "Pause a job",
-                tags: ["jobs"],
-                parameters: [
-                    {
-                        name: "jobId",
-                        in: "path",
-                        required: true,
-                        schema: { type: "string" },
-                    },
-                ],
+                summary: "Pause jobs",
+                tags: ["schedule"],
                 responses: {
                     "200": {
                         description: "Paused",
@@ -139,7 +252,7 @@ export const openapi = {
                                     type: "object",
                                     properties: {
                                         paused: { type: "boolean", example: true },
-                                        jobId: { type: "string", example: "job-123" },
+                                        jobs: { type: "number", example: 4 },
                                     },
                                 },
                             },
@@ -148,27 +261,20 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/resume/{jobId}": {
+        "/api/pause/job/{jobId}": {
             post: {
-                summary: "Resume a job",
-                tags: ["jobs"],
-                parameters: [
-                    {
-                        name: "jobId",
-                        in: "path",
-                        required: true,
-                        schema: { type: "string" },
-                    },
-                ],
+                summary: "Pause a job",
+                tags: ["schedule"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
                 responses: {
                     "200": {
-                        description: "Resumed",
+                        description: "Paused",
                         content: {
                             "application/json": {
                                 schema: {
                                     type: "object",
                                     properties: {
-                                        resumed: { type: "boolean", example: true },
+                                        paused: { type: "boolean", example: true },
                                         jobId: { type: "string", example: "job-123" },
                                     },
                                 },
@@ -178,20 +284,21 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/pause/": {
+        "/api/resume/job/{jobId}": {
             post: {
-                summary: "Pause all jobs",
-                tags: ["jobs"],
+                summary: "Resume a paused job",
+                tags: ["schedule"],
+                parameters: [{ $ref: "#/components/parameters/JobId" }],
                 responses: {
                     "200": {
-                        description: "Paused",
+                        description: "Resumed",
                         content: {
                             "application/json": {
                                 schema: {
                                     type: "object",
                                     properties: {
-                                        paused: { type: "boolean", example: true },
-                                        jobs: { type: "number", example: 4 },
+                                        resumed: { type: "boolean", example: true },
+                                        jobId: { type: "string", example: "job-123" },
                                     },
                                 },
                             },
@@ -200,10 +307,10 @@ export const openapi = {
                 },
             },
         },
-        "/api/jobs/resume/": {
+        "/api/resume": {
             post: {
-                summary: "Resume all jobs",
-                tags: ["jobs"],
+                summary: "Resume paused jobs",
+                tags: ["schedule"],
                 responses: {
                     "200": {
                         description: "Resumed",

package/dist/api/webapi.js

@@ -5,7 +5,7 @@ import { openapi } from "./openapi.js";
 const app = Fastify();
 const port = Number(process.env[ENV.PORT] ?? 8118);
 const host = process.env[ENV.HOST] ?? "127.0.0.1";
-const baseUrl = process.env[ENV.BASE_URL] ?? "http://127.0.0.1:8118";
+const baseUrl = process.env[ENV.BASE_URL] ?? `http://127.0.0.1:${port}`;
 const apiKey = process.env[ENV.API_KEY];
 app.addHook("preHandler", async (request, reply) => {
     if (request.method === "OPTIONS" || !request.url.startsWith("/api"))
@@ -38,7 +38,33 @@ app.get("/health", async (request, reply) => {
     const jobs = jobScheduler.getScheduledJobs();
     reply.code(200).send({ status: "ok", active_jobs: jobs.length });
 });
-app.post("/api/jobs/trigger/:jobId", async (request, reply) => {
+app.get("/api/jobs", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    return jobScheduler.getScheduledJobs();
+});
+app.get("/api/jobs/:jobId", async (request, reply) => {
+    const { jobId } = request.params;
+    const jobScheduler = request.server.scheduler;
+    if (!jobScheduler.isJobScheduled(jobId)) {
+        return reply.code(404).send();
+    }
+    return jobScheduler.getJob(jobId);
+});
+app.get("/api/status", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    return jobScheduler.getScheduledJobsInfo();
+});
+app.post("/api/pause", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    await jobScheduler.pauseScheduling();
+    return { paused: true };
+});
+app.post("/api/resume", async (request) => {
+    const jobScheduler = request.server.scheduler;
+    await jobScheduler.resumeScheduling();
+    return { resumed: true };
+});
+app.post("/api/trigger/:jobId", async (request, reply) => {
     const { jobId } = request.params;
     const jobScheduler = request.server.scheduler;
     if (!jobScheduler.isJobScheduled(jobId)) {

package/dist/handlers/AbstractHandler.js

@@ -141,12 +141,12 @@ export class AbstractHandler {
         await Promise.all(targetScanPromises);
         fileHistory.cleanup();
     }
-    async setTargetFilePermissions(destPath, perms, isDir = false) {
+    async setTargetFilePermissions(destFile, perms, isDir = false) {
         const mode = isDir ? perms.dirMode : perms.fileMode;
         if (perms.uid >= 0 && perms.gid >= 0)
-            await fsx.chown(destPath, perms.uid, perms.gid);
+            await fsx.chown(destFile, perms.uid, perms.gid);
         if (mode >= 0)
-            await fsx.chmod(destPath, mode);
+            await fsx.chmod(destFile, mode);
     }
     getFolderPermissionPromises(ctx, dirPath, folderPromises) {
         if (dirPath.length < ctx.targetDir.length || folderPromises.has(dirPath))

package/dist/handlers/ExecHandler.js

@@ -17,7 +17,6 @@ export class ExecHandler extends AbstractHandler {
         await super.cleanup(ctx, fileHistory);
     }
     async exec(ctx, entry) {
-        const { targetDir } = ctx;
         const verbose = ctx.job.verbose === true;
         await new Promise((resolve, reject) => {
             const { vars, env } = this.createVars(ctx, entry);
@@ -42,7 +41,6 @@ export class ExecHandler extends AbstractHandler {
                 stdio: ["ignore", verbose ? logFd : "ignore", verbose ? logFd : "ignore"],
                 shell: ctx.job.shell ?? this.setup.shell,
                 env: { ...process.env, ...env },
-                cwd: targetDir,
             });
             pid = child.pid;
             ctx.writeLog(`◉ Subprocess started (pid:${pid}) ➜ ${cmd} [${args}]`);

package/dist/models/JobRunnerSetup.js

@@ -27,14 +27,14 @@ export class JobRunnerSetup {
     targetRootDirs;
     handlerMap = new Map();
     constructor(options = {}) {
-        this.sourceRoot = resolve(options.sourceRoot ?? process.env[ENV.SOURCE_ROOT] ?? "./");
-        this.targetRoot = resolve(options.targetRoot ?? process.env[ENV.TARGET_ROOT] ?? "./");
-        this.source2Root = resolve(options.source2Root ?? process.env[ENV.SOURCE_2_ROOT] ?? "./");
-        this.target2Root = resolve(options.target2Root ?? process.env[ENV.TARGET_2_ROOT] ?? "./");
-        this.source3Root = resolve(options.source3Root ?? process.env[ENV.SOURCE_3_ROOT] ?? "./");
-        this.target3Root = resolve(options.target3Root ?? process.env[ENV.TARGET_3_ROOT] ?? "./");
-        this.configDir = resolve(options.configDir ?? process.env[ENV.CONFIG_DIR] ?? join(os.homedir(), ".cronops", "config"));
-        this.logDir = resolve(options.logDir ?? process.env[ENV.LOG_DIR] ?? join(os.homedir(), ".cronops", "logs"));
+        this.sourceRoot = resolve(options.sourceRoot ?? process.env[ENV.SOURCE_ROOT] ?? "./data");
+        this.targetRoot = resolve(options.targetRoot ?? process.env[ENV.TARGET_ROOT] ?? "./data");
+        this.source2Root = resolve(options.source2Root ?? process.env[ENV.SOURCE_2_ROOT] ?? "./data");
+        this.target2Root = resolve(options.target2Root ?? process.env[ENV.TARGET_2_ROOT] ?? "./data");
+        this.source3Root = resolve(options.source3Root ?? process.env[ENV.SOURCE_3_ROOT] ?? "./data");
+        this.target3Root = resolve(options.target3Root ?? process.env[ENV.TARGET_3_ROOT] ?? "./data");
+        this.configDir = resolve(options.configDir ?? process.env[ENV.CONFIG_DIR] ?? "./config");
+        this.logDir = resolve(options.logDir ?? process.env[ENV.LOG_DIR] ?? "./logs");
         this.tempDir = resolve(options.tempDir ?? process.env[ENV.TEMP_DIR] ?? join(os.tmpdir(), "cronops"));
         this.uid = options.uid ?? process.env[ENV.PUID] ?? `${process.getuid?.() ?? "0"}`;
         this.gid = options.gid ?? process.env[ENV.PGID] ?? `${process.getgid?.() ?? "0"}`;

package/dist/server.js

@@ -34,18 +34,25 @@ export async function start() {
         console.log(`🔴 Error loading job '${entry}'. ${message}`);
     });
     jobLoader.onJobLoaded((job) => {
-        if (job.enabled !== false)
-            jobScheduler.scheduleJob(job);
+        jobScheduler.scheduleJob(job);
     });
     jobLoader.onJobDeleted((jobId) => {
         jobScheduler.unscheduleJob(jobId);
     });
     jobScheduler.onChanged((isReload) => {
-        const jobs = jobScheduler.getScheduledJobs();
-        console.log(`\nJob config ${isReload ? "changed" : "loaded"} (${plural(jobs.length, "active job")})`);
+        const jobs = jobScheduler.getScheduledJobsInfo();
+        console.log(`\nJob config ${isReload ? "changed" : "loaded"}`);
         for (const job of jobs) {
-            console.log(` 🕔 [${job.id}] scheduled (${chalk.greenBright(job.cron)})${job.dry_run ? " 👋 DRY-RUN mode!" : ""}`);
+            if (job.status !== "paused")
+                console.log(` 🕔 [${job.id}] scheduled (${chalk.greenBright(job.cron)})${job.dry_run ? " 👋 DRY-RUN mode!" : ""}`);
         }
+        for (const job of jobs) {
+            if (job.status === "paused")
+                console.log(` ⚫ [${job.id}] inactive`);
+        }
+    });
+    jobScheduler.onJobExecute((job) => {
+        console.error(`[${job.id}] triggered manually`);
     });
     jobScheduler.onJobError((job, err) => {
         console.error(chalk.red(`[${job.id}] ERROR ${err.message}`));

package/dist/tasks/AbstractTask.d.ts

@@ -1,17 +1,26 @@
 import { type ScheduledTask } from "node-cron";
 import { EventEmitter } from "node:events";
-import type { Task } from "../types/Task.types.js";
+import type { Task, TaskInfo } from "../types/Task.types.js";
 export declare abstract class AbstractTask<T> implements Task {
     protected cronTask: ScheduledTask;
     protected events: EventEmitter<any>;
     protected errorCount: number;
+    private runCount;
+    private isScheduled;
     private isRunning;
+    private isPaused;
+    private lastRun?;
+    private lastDuration?;
     constructor(cronStr?: string);
     protected abstract run(): Promise<T>;
     schedule(runImmediately?: boolean): void;
     unschedule(): void;
-    execute(cb?: (result: T) => void): void;
+    pause(): void;
+    resume(): void;
+    getInfo(): TaskInfo;
+    execute<T>(): Promise<T>;
     onScheduled(cb: () => void): void;
+    onExecute(cb: () => void): void;
     onStarted(cb: () => void): void;
     onFinished<T>(cb: (result: T) => void): void;
     onError(cb: (error: Error) => void): void;

package/dist/tasks/AbstractTask.js

@@ -1,4 +1,4 @@
-import cron, {} from "node-cron";
+import cron from "node-cron";
 import { setTimeout } from "node:timers/promises";
 import { EventEmitter } from "node:events";
 import { ENV } from "../types/Options.types.js";
@@ -6,20 +6,29 @@ export class AbstractTask {
     cronTask;
     events = new EventEmitter();
     errorCount = 0;
+    runCount = 0;
+    isScheduled = false;
     isRunning = false;
+    isPaused = false;
+    lastRun;
+    lastDuration;
     constructor(cronStr = "* * * * *") {
         const asyncRunner = async () => {
-            if (!this.isRunning) {
+            if (!this.isRunning && !this.isPaused) {
+                this.runCount++;
                 this.isRunning = true;
+                this.lastRun = Date.now();
                 try {
                     this.events.emit("started");
                     this.events.emit("finished", await this.run());
                 }
                 catch (err) {
+                    this.errorCount++;
                     this.events.emit("error", err instanceof Error ? err : new Error(String(err)));
                 }
                 finally {
                     this.isRunning = false;
+                    this.lastDuration = Date.now() - this.lastRun;
                 }
             }
         };
@@ -30,26 +39,45 @@ export class AbstractTask {
     }
     schedule(runImmediately = false) {
         if (runImmediately)
-            this.cronTask.once("task:started", () => this.execute());
+            this.cronTask.once("task:started", () => this.cronTask.execute());
         this.cronTask.start();
+        this.isScheduled = true;
     }
     unschedule() {
         this.events.removeAllListeners();
         this.cronTask.destroy();
+        this.isScheduled = false;
     }
-    execute(cb) {
+    pause() {
+        this.isPaused = true;
+    }
+    resume() {
+        this.isPaused = false;
+    }
+    getInfo() {
+        return {
+            status: this.isRunning ? "running" : this.isPaused ? "paused" : this.isScheduled ? "scheduled" : "unscheduled",
+            runCount: this.runCount,
+            errorCount: this.errorCount,
+            lastRun: this.lastRun,
+            lastDuration: this.lastDuration,
+        };
+    }
+    execute() {
         const status = this.cronTask.getStatus();
         if (status === "destroyed")
             throw new Error("Invalid task state (destroyed)");
         if (status === "running" || this.isRunning)
             throw new Error("Invalid task state (running)");
-        if (cb)
-            this.events.once("finished", cb);
-        this.cronTask.execute();
+        this.events.emit("execute");
+        return this.cronTask.execute();
     }
     onScheduled(cb) {
         this.cronTask.on("task:started", cb);
     }
+    onExecute(cb) {
+        this.events.on("execute", cb);
+    }
     onStarted(cb) {
         this.events.on("started", cb);
     }
@@ -57,7 +85,6 @@ export class AbstractTask {
         this.events.on("finished", cb);
     }
     onError(cb) {
-        this.errorCount++;
         this.events.on("error", (error) => cb(error));
     }
     async gracefulTerminate(timeout = 500) {

package/dist/tasks/JobRunner.d.ts

@@ -1,5 +1,4 @@
 import { AbstractTask } from "./AbstractTask.js";
-import { JobRunnerResult } from "../models/JobRunnerResult.js";
 import type { JobModel } from "../models/JobModel.js";
 import type { JobRunnerSetup } from "../models/JobRunnerSetup.js";
 import type { RunnerResult, FileHistory } from "../types/Task.types.js";
@@ -9,8 +8,8 @@ export declare class JobRunner extends AbstractTask<RunnerResult> {
     setup: JobRunnerSetup;
     constructor(job: JobModel, setup: JobRunnerSetup);
     onActivity(cb: (action: string, path: string, count: number) => void): void;
-    runJob(): Promise<JobRunnerResult>;
-    protected run(): Promise<JobRunnerResult>;
+    runJob(): Promise<RunnerResult>;
+    protected run(): Promise<RunnerResult>;
     protected loadFileHistory(job: Job): Promise<FileHistory>;
     protected saveFileHistory(job: Job, fileHistory: FileHistory): Promise<void>;
     protected initLog(job: Job): number;

package/dist/tasks/JobRunner.js

@@ -4,7 +4,6 @@ import { ensureDir, moveSync, readJSON, writeJSON } from "fs-extra/esm";
 import { AbstractTask } from "./AbstractTask.js";
 import { JobRunnerContext } from "../models/JobRunnerContext.js";
 import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
-import { JobRunnerResult } from "../models/JobRunnerResult.js";
 import { FileHistoryModel } from "../models/FileHistoryModel.js";
 export class JobRunner extends AbstractTask {
     job;
@@ -22,10 +21,8 @@ export class JobRunner extends AbstractTask {
     }
     async run() {
         const { setup, job, events } = this;
-        if (job.enabled === false)
-            return new JobRunnerResult();
-        if (this.errorCount >= 25) {
-            job.enabled = false;
+        if (this.errorCount >= 31) {
+            this.pause();
             throw new Error("Too many errors. Job execution disabled!");
         }
         await ensureDir(setup.logDir);

package/dist/tasks/JobScheduler.d.ts

@@ -2,8 +2,9 @@ import { JobRunner } from "./JobRunner.js";
 import { JobRunnerSetup } from "../models/JobRunnerSetup.js";
 import { AbstractTask } from "./AbstractTask.js";
 import type { Job } from "../types/Config.types.js";
-import type { RunnerResult } from "../types/Task.types.js";
+import type { RunnerResult, TaskInfo } from "../types/Task.types.js";
 import type { RunnerOptions } from "../types/Options.types.js";
+type SchedulingInfo = Job & TaskInfo;
 export declare class JobScheduler extends AbstractTask<void> {
     protected runnerSetup: JobRunnerSetup;
     protected runnerMap: Map<string, JobRunner>;
@@ -13,19 +14,29 @@ export declare class JobScheduler extends AbstractTask<void> {
     get scheduledJobs(): number;
     get tempDir(): string;
     protected run(): Promise<void>;
+    pauseAll(): void;
+    resumeAll(): void;
     unscheduleAll(): void;
     scheduleJobs(jobs: Job[], cb?: (count: number) => void): void;
-    scheduleJob(job: Job, defaults?: {}): void;
+    scheduleJob(job: Job): void;
     unscheduleJob(jobId: string): void;
     isJobScheduled(jobId: string): boolean;
+    getJob(jobId: string): Job | undefined;
     executeJob(jobId: string): void;
     validateJob(job: Job): void;
+    pauseScheduling(): void;
+    resumeScheduling(): void;
+    pauseJobScheduling(jobId: string): void;
+    resumeJobScheduling(jobId: string): void;
     getScheduledJobs(): Job[];
+    getScheduledJobsInfo(): SchedulingInfo[];
     gracefulTerminate(timeout?: number): Promise<void>;
     onChanged(cb: (initialConfig: boolean) => void): void;
     onJobScheduled(cb: (job: Job, rescheduled: boolean) => void): void;
+    onJobExecute(cb: (job: Job) => void): void;
     onJobStarted(cb: (job: Job) => void): void;
     onJobFinished(cb: (job: Job, stat: RunnerResult) => void): void;
     onJobActivity(cb: (job: Job, activity: string, path: string, count: number) => void): void;
     onJobError(cb: (job: Job, err: Error) => void): void;
 }
+export {};