@live-change/cron-service 0.9.163 → 0.9.164

package/config.js

@@ -2,12 +2,14 @@ import definition from './definition.js'
 
 const {
   adminRoles = ['admin', 'owner'],
+  readerRoles = ['reader'],
   ownerTypes = ['user_User'],
-  topicTypes = ['topic_Topic']
+  topicTypes = undefined
 } = definition.config
 
 const config = {
   adminRoles,
+  readerRoles,
   ownerTypes,
   topicTypes
 } 

package/interval.js

@@ -3,7 +3,7 @@ const app = App.app()
 
 import definition from './definition.js'
 import config from './config.js'
-import { triggerType } from './run.js'
+import { triggerType, runTrigger, doRunTrigger, waitForTasks, RunState } from './run.js'
 
 export const Interval = definition.model({
   name: "Interval",
@@ -15,31 +15,85 @@ export const Interval = definition.model({
       roles: config.adminRoles
     },
     readAccessControl: {
-      roles: config.adminRoles
+      roles: [...config.adminRoles, ...config.readerRoles]
     },
     readAllAccess: ['admin'],
   },
   properties: {
     description: {
       type: String,
-      description: "Description of the interval"
+      description: "Description of the interval",
+      input: 'textarea',
     },
     interval: {
       type: Number, // milliseconds      
-      description: "Interval between triggers in milliseconds"
+      description: "Interval between triggers in milliseconds",
+      validation: ['nonEmpty', 'integer'],
+      input: 'integer',
+      inputConfig: {
+        attributes: {
+          suffix: ' ms',
+          showButtons: true,
+          step: 1000,
+          min: 1000,
+        }
+      }
+    },
+    firstRunDelay: {
+      type: Number, // milliseconds 
+      description: "Delay before first run",
+      input: 'integer',
+      inputConfig: {
+        attributes: {
+          suffix: ' ms',
+          showButtons: true,
+          step: 1000,
+          min: 0,
+        }
+      }
     },
     wait: {
       type: Number, // milliseconds 
-      description: "Wait for previous trigger to finish before planning next trigger"     
+      description: "Wait for previous trigger to finish before planning next trigger",
+      input: 'integer',
+      inputConfig: {
+        attributes: {
+          suffix: ' ms',
+          showButtons: true,
+          step: 1000,
+          min: 0,
+        }
+      }
     },
     trigger: triggerType
   }
 })
 
-async function processInterval({ id, interval, wait, trigger }) {
+export const IntervalInfo = definition.model({
+  name: "IntervalInfo",
+  propertyOf: {
+    what: Interval,
+    readAccessControl: {
+      roles: [...config.adminRoles, ...config.readerRoles]
+    }
+  },
+  properties: {
+    lastRun: {
+      type: Date
+    },
+    nextRun: {
+      type: Date
+    }
+  }
+})
+
+async function processInterval({ id, interval, wait, trigger, firstRunDelay, isFirstRun }, { triggerService }) {
+  //console.log("PROCESSING INTERVAL", id, interval, wait, trigger, firstRunDelay, isFirstRun)
   if(wait) await waitForTasks('cron_Interval', id)
-  const nextTimestamp = Date.now() + interval
+  //console.log("WAIT FOR TASKS DONE", id)
+  const nextTimestamp = Date.now() + (isFirstRun ? (firstRunDelay || 0) : interval)
   const nextTime = new Date(nextTimestamp)
+  //console.log("NEXT TIME", nextTime)
   await triggerService({
     service: 'timer',
     type: 'createTimer',
@@ -59,6 +113,11 @@ async function processInterval({ id, interval, wait, trigger }) {
       }
     }
   })
+  await IntervalInfo.update(id, {
+    id,    
+    nextRun: nextTime
+  })
+  //console.log("TIMER CREATED", id)
 }
 
 
@@ -73,22 +132,34 @@ definition.trigger({
     const intervalData = await Interval.get(interval)
     if(!intervalData) return /// interval was deleted
     if(intervalData.wait) {
+      const lastRun = new Date()
       await runTrigger(intervalData.trigger, {
         trigger,
         triggerService,
         jobType: 'cron_Interval',
         job: interval,
-        timeout: Number.isInteger(intervalData.wait) ? intervalData.wait : undefined
+        timeout: Number.isInteger(intervalData.wait) ? intervalData.wait : undefined,
+        runTime: lastRun
       })
-      await processInterval(intervalData)
+      await IntervalInfo.update(interval, {
+        id: interval,
+        lastRun       
+      })
+      await processInterval(intervalData, { triggerService })
     } else {
-      await processInterval(intervalData) // no wait, process immediately
+      await processInterval(intervalData, { triggerService }) // no wait, process immediately
       try {
+        const lastRun = new Date()
         await doRunTrigger(intervalData.trigger, {
           trigger,
           triggerService,
           jobType: 'cron_Interval',
-          job: interval
+          job: interval,
+          runTime: lastRun
+        })
+        await IntervalInfo.update(interval, {
+          id: interval,
+          lastRun
         })
       } catch(error) {
         console.error("ERROR RUNNING INTERVAL TRIGGER", error)
@@ -116,27 +187,28 @@ definition.trigger({
     if(oldData) { // clear old version
       await triggerService({
         service: 'timer',
-        type: 'cancelTimerIfExists',
-        data: {
-          timer: 'cron_Interval_' + object.id
-        }
+        type: 'cancelTimerIfExists',        
+      }, {
+        timer: 'cron_Interval_' + object
       })
       if(!data) { // full cleanup
         await triggerService({
           service: 'timer',
-          type: 'cancelTimerIfExists',
-          data: {
-            timer: 'cron_run_timeout_' + object.id
-          }
+          type: 'cancelTimerIfExists',          
+        }, {
+          timer: 'cron_run_timeout_' + object
         })
-        RunState.delete(App.encodeIdentifier(['cron_Interval', object.id]))
+        RunState.delete(App.encodeIdentifier(['cron_Interval', object]))
       }
     }
     if(data) { // setup new version
+      console.log("PROCESSING INTERVAL", object, data)
       await processInterval({
-        id: object,
-        ...data``
-      })
+          id: object,
+          ...data,
+          isFirstRun: !oldData
+        }, { triggerService })
+      console.log("PROCESSING INTERVAL DONE", object, data)
     }
   }
 })
@@ -156,7 +228,14 @@ definition.afterStart(async (service) => {
       const existingTimer = await Timer.get('cron_Interval_' + interval.id)
       if(!existingTimer) {
         console.error("INTERVAL", interval, "HAS NO TIMER, REPROCESSING")
-        await processInterval(interval)
+        await processInterval(interval, { 
+          triggerService: (trigger, data, returnArray = false) => 
+            app.triggerService({ 
+              ...trigger,
+              causeType: 'cron_Interval',
+              cause: 'cron_Interval_' + interval.id,
+            }, data, returnArray) 
+        })
       }
     }    
   } while(bucket.length === bucketSize)    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/cron-service",
-  "version": "0.9.163",
+  "version": "0.9.164",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -22,7 +22,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@live-change/framework": "^0.9.163"
+    "@live-change/framework": "^0.9.164"
   },
-  "gitHead": "c410e1dacd07daed9a5c55367abd7f19d9a575cc"
+  "gitHead": "38f9fb8b01a9527d8f6036e174edd1fa41443301"
 }

package/run.js

@@ -4,12 +4,16 @@ const app = App.app()
 import definition from './definition.js'
 
 const Task = definition.foreignModel('task', 'Task')
+import config from './config.js'
 
 export const RunState = definition.model({
   name: "RunState",
   propertyOfAny: {
     to: ['job'],
-    jobTypes: ['cron_Interval', 'cron_Schedule']
+    jobTypes: ['cron_Interval', 'cron_Schedule'],
+    readAccessControl: {
+      roles: [...config.adminRoles, ...config.readerRoles]
+    }
   },
   properties: {
     state: {
@@ -37,43 +41,57 @@ export const RunState = definition.model({
   }
 })
 
-
 export const triggerType = {  
   description: "Trigger to schedule",
-  input: 'triggerEditor',
+  input: 'trigger',
   type: Object,
   properties: {
     name: {
       description: "Trigger name",
       type: String,
+      validation: ['nonEmpty']
     },
     service: {
       description: "Service holding the trigger, or null for triggering any service",
       type: String,
+      validation: ['nonEmpty']
     },
     properties: {
       description: "Properties to pass to the trigger",
-      type: Object,      
+      type: Object,
+      input: 'json',
+      defaultValue: {}
+    },
+    returnTask: {
+      description: "Return task to wait for",
+      type: Boolean,
+      defaultValue: false
     }
   }
 }
 
-export async function doRunTrigger(triggerInfo, { trigger, triggerService, jobType, job }) {
+export async function doRunTrigger(triggerInfo, { trigger, triggerService, jobType, job, runTime }) {
   if(triggerInfo.service) {
     return await triggerService({
       type: triggerInfo.name,
       service: triggerInfo.service,
       causeType: jobType, cause: job
-    }, triggerInfo.properties, true)
+    }, {
+      ...triggerInfo.properties,
+      jobRunTime: runTime
+    }, true)
   } else {
     return await trigger({
       type: triggerInfo.name,
       causeType: jobType, cause: job
-    }, triggerInfo.properties)
+    }, {
+      ...triggerInfo.properties,
+      jobRunTime: runTime
+    })
   }
 }
 
-export async function runTrigger(triggerInfo, { trigger, triggerService, jobType, job, timeout }) {
+export async function runTrigger(triggerInfo, { trigger, triggerService, jobType, job, timeout, runTime }) {
   const id = App.encodeIdentifier([jobType, job])
   await RunState.create({    
     id,
@@ -104,13 +122,13 @@ export async function runTrigger(triggerInfo, { trigger, triggerService, jobType
   }
   let triggerResults = []
   try {
-    triggerResults = await doRunTrigger(triggerInfo, { trigger, triggerService, jobType, job })
+    triggerResults = await doRunTrigger(triggerInfo, { trigger, triggerService, jobType, job, runTime })
   } catch(error) {
     console.error("ERROR RUNNING TRIGGER", error)   
     /// Ignore error, it will be handled by the task service
   }
   if(triggerInfo.returnTask) {
-    const tasks = await Promise.all(triggerResults.map((result) => Task.get(result)))
+    const tasks = (await Promise.all(triggerResults.map((result) => Task.get(result))))
       .filter(task => task !== undefined)
       .filter(task => task.state !== 'done' && task.state !== 'failed')
     if(tasks.length > 0) {
@@ -185,7 +203,7 @@ export async function waitForTasks(jobType, job) {
     }
     const runStateObservable = RunState.observable(runState)
     const runStateObserver = {
-      set: (value) => {
+      set: (value) => {        
         if(!value) finish()
         if(value.tasks) {
           for(const taskId of value.tasks) {
@@ -194,6 +212,7 @@ export async function waitForTasks(jobType, job) {
         }
       }
     }
+    runStateObservable.observe(runStateObserver)
     function finish() {
       if(done) return
       done = true

package/schedule.js

@@ -3,7 +3,7 @@ const app = App.app()
 
 import definition from './definition.js'
 import config from './config.js'
-import { triggerType } from './run.js'
+import { triggerType, runTrigger, doRunTrigger, waitForTasks } from './run.js'
 
 export const Schedule = definition.model({
   name: "Schedule",
@@ -21,30 +21,104 @@ export const Schedule = definition.model({
   },
   properties: {
     description: {
-      type: String
+      type: String,
+      description: "Description of the schedule",
+      input: 'textarea',
     },
     minute: {
-      type: Number // NaN for every minute      
+      type: Number, // NaN for every minute      
+      description: "Minute of the hour to run the schedule",
+      input: 'integer',
+      inputConfig: {
+        attributes: {          
+          showButtons: true,
+          step: 1,
+          min: 0,
+          max: 59,
+        }
+      }
     },
     hour: {
       type: Number, // NaN for every hour      
+      description: "Hour of the day to run the schedule",
+      input: 'integer',
+      inputConfig: {
+        attributes: {          
+          showButtons: true,
+          step: 1,
+          min: 0,
+          max: 23,
+        }
+      }
     },
     day: {
       type: Number, // NaN for every day      
+      description: "Day of the month to run the schedule",
+      input: 'integer',
+      inputConfig: {
+        attributes: {          
+          showButtons: true,
+          step: 1,
+          min: 1,
+          max: 31,
+        }
+      }
     },
     dayOfWeek: {
       type: Number, // NaN for every day of week      
+      description: "Day of the week to run the schedule",
+      input: 'integer',
+      inputConfig: {
+        attributes: {          
+          showButtons: true,
+          step: 1,
+          min: 1,
+          max: 7,
+        }
+      }
     },
     month: {
       type: Number, // NaN for every month      
+      description: "Month of the year to run the schedule",
+      input: 'integer',
+      inputConfig: {
+        attributes: {          
+          showButtons: true,
+          step: 1,
+          min: 1,
+          max: 12,
+        }
+      }
     },
     trigger: triggerType
   }
 })
 
+export const ScheduleInfo = definition.model({
+  name: "ScheduleInfo",
+  propertyOf: {
+    what: Schedule,
+    readAccessControl: {
+      roles: [...config.adminRoles, ...config.readerRoles]
+    }
+  },
+  properties: {
+    lastRun: {
+      type: Date
+    },
+    nextRun: {
+      type: Date
+    }
+  }
+})
+
 function getNextTime(schedule) {
   const now = new Date()
   let time = now
+
+  /// set to next minute
+  time = new Date(time.getFullYear(), time.getMonth(), time.getDate(), time.getHours(), time.getMinutes() + 1, 0)
+
   if(Number.isInteger(schedule.minute)) {
     if(time.getMinutes() >= schedule.minute) { // next hour
       time = new Date(time.getFullYear(), time.getMonth(), time.getDate(), time.getHours() + 1, schedule.minute, 0)
@@ -72,8 +146,8 @@ function getNextTime(schedule) {
   return time
 }
 
-async function processSchedule({ id, minute, hour, day, dayOfWeek, month, trigger }) {
-  const nextTime = getNextTime(schedule)
+async function processSchedule({ id, minute, hour, day, dayOfWeek, month, trigger }, { triggerService }) {
+  const nextTime = getNextTime({ minute, hour, day, dayOfWeek, month })
   const nextTimestamp = nextTime.getTime()
   await triggerService({
     service: 'timer',
@@ -94,6 +168,10 @@ async function processSchedule({ id, minute, hour, day, dayOfWeek, month, trigge
       }
     }
   })
+  await ScheduleInfo.update(id, {
+    id,    
+    nextRun: nextTime
+  })
 }
 
 definition.trigger({
@@ -106,18 +184,23 @@ definition.trigger({
   execute: async ({ schedule }, { service, trigger, triggerService }, emit) => {
     const scheduleData = await Schedule.get(schedule)
     if(!scheduleData) return /// schedule was deleted
-    await processSchedule(scheduleData) // no wait, process immediately
+    await processSchedule(scheduleData, { triggerService }) // no wait, process immediately
     try {
+      const lastRun = new Date()
       await doRunTrigger(scheduleData.trigger, {
         trigger,
         triggerService,
         jobType: 'cron_Schedule',
-        job: schedule
+        job: schedule,
+        runTime: lastRun
+      })
+      await ScheduleInfo.update(schedule, {
+        id: schedule,
+        lastRun
       })
     } catch(error) {
       console.error("ERROR RUNNING SCHEDULE TRIGGER", error)
     }
-    
   }
 })
 
@@ -140,16 +223,16 @@ definition.trigger({
       await triggerService({
         service: 'timer',
         type: 'cancelTimerIfExists',
-        data: {
-          timer: 'cron_Schedule_' + object.id
-        }
+      }, {        
+        timer: 'cron_Schedule_' + object        
       })
+      await ScheduleInfo.delete(object)
     }
     if(data) {
       await processSchedule({
         id: object,
         ...data
-      })
+      }, { triggerService })
     }
   }
 })
@@ -170,7 +253,14 @@ definition.afterStart(async (service) => {
     const existingTimer = await Timer.get('cron_Schedule_' + schedule.id)
     if(!existingTimer) {
       console.error("SCHEDULE", schedule, "HAS NO TIMER, REPROCESSING")
-      await processSchedule(schedule)
+      await processSchedule(schedule, { 
+        triggerService: (trigger, data, returnArray = false) => 
+          app.triggerService({ 
+            ...trigger,
+            causeType: 'cron_Schedule',
+            cause: 'cron_Schedule_' + schedule.id,
+          }, data, returnArray) 
+      })
     }
   }
 })