@cloudnux/local-cloud-provider 0.7.0 → 0.10.0

package/dist/schedule-plugin/index.d.ts

@@ -81,7 +81,9 @@ interface SchedulerState {
     executionHistory: JobExecution[];
     isShuttingDown: boolean;
     runningExecutions: number;
-    cleanupInterval?: NodeJS.Timeout;
+    tickInterval?: NodeJS.Timeout;
+    isDirty: boolean;
+    lastCleanupTime: number;
     lastRestartTime: Date;
     config: SchedulerConfig;
 }

package/dist/schedule-plugin/index.js

@@ -1301,17 +1301,22 @@ var scheduleJob = (scheduler, state, executeJobFn) => {
     updatedScheduler.timerId = setTimeout(() => {
       executeJobFn(updatedScheduler);
     }, timeUntilNextRun);
-    logger.info(`${chalk3.blue("\u{1F4C5} Scheduled job")} ${chalk3.green(scheduler.job.name)} to run in ${chalk3.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
+    logger.debug(`${chalk3.blue("\u{1F4C5} Scheduled job")} ${chalk3.green(scheduler.job.name)} to run in ${chalk3.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
   }
   return updatedScheduler;
 };
 var executeJobWithTimeout = async (handler, job, execution, timeoutMs) => {
-  return Promise.race([
-    handler(job, execution),
-    new Promise(
-      (_, reject) => setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs)
-    )
-  ]);
+  let timerId;
+  try {
+    return await Promise.race([
+      handler(job, execution),
+      new Promise((_, reject) => {
+        timerId = setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timerId);
+  }
 };
 var updateJobAfterExecution = (job, execution, config) => {
   const updatedJob = {
@@ -1354,7 +1359,7 @@ var saveSchedulerState = async (state) => {
     const tempFile = createTempFilePath(state.config.persistence.directory);
     await fs.writeFile(tempFile, JSON.stringify(serializedState, null, 2), "utf8");
     await fs.rename(tempFile, stateFile);
-    logger.info(`${logSymbols2.info} ${chalk4.blue("Enhanced scheduler state saved")}`);
+    logger.debug(`${logSymbols2.info} ${chalk4.blue("Enhanced scheduler state saved")}`);
   } catch (error) {
     logger.error("Failed to save scheduler state:", error);
   }
@@ -1366,7 +1371,7 @@ var loadSchedulerStateData = async (directory) => {
     return JSON.parse(data);
   } catch (error) {
     if (error.code === "ENOENT") {
-      logger.info(`${chalk4.blue("No previous scheduler state found - starting fresh")}`);
+      logger.debug(`${chalk4.blue("No previous scheduler state found - starting fresh")}`);
     } else {
       logger.error("Failed to load scheduler state:", error);
     }
@@ -1379,20 +1384,20 @@ var validateAndAdjustNextRun = (job, savedNextRun, lastRestartTime, config) => {
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   if (savedNextRun <= now) {
-    logger.info(`${chalk4.yellow("\u23F0 Saved next run is in the past for")} ${chalk4.green(job.name)} - recalculating`);
+    logger.debug(`${chalk4.yellow("\u23F0 Saved next run is in the past for")} ${chalk4.green(job.name)} - recalculating`);
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   const timeSinceRestart = now.getTime() - lastRestartTime.getTime();
   const isRapidRestart = timeSinceRestart < config.restartBehavior.rapidRestartThreshold;
   if (isRapidRestart) {
-    logger.info(`${chalk4.blue("\u26A1 Rapid restart detected for")} ${chalk4.green(job.name)} - preserving saved timing`);
+    logger.debug(`${chalk4.blue("\u26A1 Rapid restart detected for")} ${chalk4.green(job.name)} - preserving saved timing`);
     return savedNextRun;
   }
   if (job.cronExpression || job.intervalMs) {
     const expectedNextRun = calculateNextRunFromLastRun(job, job.lastRun, config);
     const timeDiff = Math.abs(savedNextRun.getTime() - expectedNextRun.getTime());
     if (timeDiff > config.restartBehavior.maxTimingDrift) {
-      logger.info(`${chalk4.yellow("\u{1F527} Adjusting timing for")} ${chalk4.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
+      logger.debug(`${chalk4.yellow("\u{1F527} Adjusting timing for")} ${chalk4.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
       return expectedNextRun;
     }
   }
@@ -1406,7 +1411,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     lastRun: savedJob.lastRun ? new Date(savedJob.lastRun) : void 0
   };
   if (definitionChanged) {
-    logger.info(`${chalk4.yellow("\u{1F504} Job definition changed:")} ${chalk4.green(savedJob.name)} - recalculating schedule`);
+    logger.debug(`${chalk4.yellow("\u{1F504} Job definition changed:")} ${chalk4.green(savedJob.name)} - recalculating schedule`);
     updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, updatedJob.lastRun, config);
   } else {
     const savedNextRun = savedJob.nextRun ? new Date(savedJob.nextRun) : void 0;
@@ -1416,7 +1421,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     const result = parseCronExpression(updatedJob.cronExpression, updatedJob.lastRun, {
       timezone: updatedJob.timezone
     });
-    logger.info(`${chalk4.blue("\u{1F4C5} Job restored:")} ${chalk4.green(savedJob.name)} - ${result.description} - next: ${chalk4.cyan(updatedJob.nextRun.toLocaleString())}`);
+    logger.debug(`${chalk4.blue("\u{1F4C5} Job restored:")} ${chalk4.green(savedJob.name)} - ${result.description} - next: ${chalk4.cyan(updatedJob.nextRun.toLocaleString())}`);
   }
   return { ...scheduler, job: updatedJob };
 };
@@ -1459,16 +1464,11 @@ var cleanupExecutionHistory = (state) => {
       0,
       state.executionHistory.length - state.config.cleanup.maxExecutionHistory
     );
-    logger.info(`${chalk5.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
+    logger.debug(`${chalk5.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
     return removed;
   }
   return [];
 };
-var startCleanupInterval = (state) => {
-  return setInterval(() => {
-    cleanupExecutionHistory(state);
-  }, state.config.cleanup.cleanupInterval);
-};
 
 // src/schedule-plugin/core.ts
 var DEFAULT_CONFIG = {
@@ -1520,6 +1520,8 @@ var createInitialState = (config) => {
     executionHistory: [],
     isShuttingDown: false,
     runningExecutions: 0,
+    isDirty: false,
+    lastCleanupTime: Date.now(),
     lastRestartTime: /* @__PURE__ */ new Date(),
     config
   };
@@ -1552,18 +1554,18 @@ var createSchedulerFunctions = (state) => {
       );
       const completedExecution = handleExecutionSuccess(execution, result);
       state.executions[execution.id] = completedExecution;
-      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
     } catch (error) {
       const failedExecution = handleExecutionError(execution, error);
       state.executions[execution.id] = failedExecution;
     } finally {
       scheduler.isRunning = false;
       state.runningExecutions--;
+      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
       if (scheduler.job.enabled && !state.isShuttingDown) {
         scheduleJobFn(scheduler);
       }
       if (state.config.persistence.enabled) {
-        await saveSchedulerState(state);
+        state.isDirty = true;
       }
     }
   };
@@ -1585,11 +1587,18 @@ var initializeScheduler = async (state, scheduleJobFn) => {
       );
       state.schedulers = schedulers;
       state.executionHistory = executionHistory;
-      if (state.config.persistence.saveInterval > 0) {
-        setInterval(() => saveSchedulerState(state), state.config.persistence.saveInterval);
-      }
     }
-    state.cleanupInterval = startCleanupInterval(state);
+    const tickInterval = state.config.persistence.saveInterval > 0 ? state.config.persistence.saveInterval : state.config.cleanup.cleanupInterval;
+    state.tickInterval = setInterval(async () => {
+      if (state.isDirty && state.config.persistence.enabled) {
+        state.isDirty = false;
+        await saveSchedulerState(state);
+      }
+      if (Date.now() - state.lastCleanupTime >= state.config.cleanup.cleanupInterval) {
+        state.lastCleanupTime = Date.now();
+        cleanupExecutionHistory(state);
+      }
+    }, tickInterval);
     for (const scheduler of Object.values(state.schedulers)) {
       if (scheduler.job.enabled) {
         scheduleJobFn(scheduler);
@@ -1620,11 +1629,11 @@ var createJobFromDefinition = (jobDef, config) => {
     const result = parseCronExpression(cronExpression, void 0, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.info(`${chalk7.blue("\u{1F4C5} Job")} ${chalk7.green(jobDef.name)}: ${result.description} - Next: ${chalk7.cyan(result.nextRun.toLocaleString())}`);
+    logger.debug(`${chalk7.blue("\u{1F4C5} Job")} ${chalk7.green(jobDef.name)}: ${result.description} - Next: ${chalk7.cyan(result.nextRun.toLocaleString())}`);
     const upcoming = getNextExecutions(cronExpression, 3, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.info(`${chalk7.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
+    logger.debug(`${chalk7.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
   }
   const job = {
     id: generateJobId(),
@@ -1688,19 +1697,19 @@ var createExecutionsData = (state) => ({
   running: Object.values(state.executions).filter((e) => e.status === "running")
 });
 var registerDashboardRoute = (app, state) => {
-  app.get("/dashboard", async function(_, reply) {
+  app.get("/schedule/dashboard", async function(_, reply) {
     const dashboardData = createDashboardData(state);
     return reply.status(200).send(dashboardData);
   });
 };
 var registerExecutionsRoute = (app, state) => {
-  app.get("/executions", async function(_, reply) {
+  app.get("/schedule/executions", async function(_, reply) {
     const executionsData = createExecutionsData(state);
     return reply.status(200).send(executionsData);
   });
 };
 var registerTriggerJobRoute = (app, state, executeJobFn) => {
-  app.post("/jobs/:jobId/trigger", async function(request, reply) {
+  app.post("/schedule/jobs/:jobId/trigger", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -1713,7 +1722,7 @@ var registerTriggerJobRoute = (app, state, executeJobFn) => {
   });
 };
 var registerEnableJobRoute = (app, state, scheduleJobFn) => {
-  app.put("/jobs/:jobId/enable", async function(request, reply) {
+  app.put("/schedule/jobs/:jobId/enable", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -1725,7 +1734,7 @@ var registerEnableJobRoute = (app, state, scheduleJobFn) => {
   });
 };
 var registerDisableJobRoute = (app, state) => {
-  app.put("/jobs/:jobId/disable", async function(request, reply) {
+  app.put("/schedule/jobs/:jobId/disable", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -1839,7 +1848,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (scheduler.job.enabled) {
-        logger.info(`${logSymbols6.info} ${chalk8.blue("Job is already enabled:")} ${chalk8.magenta(jobName)}`);
+        logger.debug(`${logSymbols6.info} ${chalk8.blue("Job is already enabled:")} ${chalk8.magenta(jobName)}`);
         return;
       }
       scheduler.job.enabled = true;
@@ -1858,7 +1867,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (!scheduler.job.enabled) {
-        logger.info(`${logSymbols6.info} ${chalk8.blue("Job is already disabled:")} ${chalk8.magenta(jobName)}`);
+        logger.debug(`${logSymbols6.info} ${chalk8.blue("Job is already disabled:")} ${chalk8.magenta(jobName)}`);
         return;
       }
       scheduler.job.enabled = false;