@live-change/cron-service 0.9.162

package/config.js

@@ -0,0 +1,15 @@
+import definition from './definition.js'
+
+const {
+  adminRoles = ['admin', 'owner'],
+  ownerTypes = ['user_User'],
+  topicTypes = ['topic_Topic']
+} = definition.config
+
+const config = {
+  adminRoles,
+  ownerTypes,
+  topicTypes
+} 
+
+export default config

package/definition.js

@@ -0,0 +1,13 @@
+import App from '@live-change/framework'
+const app = App.app()
+
+import relationsPlugin from '@live-change/relations-plugin'
+import accessControlService from '@live-change/access-control-service'
+import taskService from '@live-change/task-service'
+
+const definition = app.createServiceDefinition({
+  name: "cron", 
+  use: [ relationsPlugin, accessControlService, taskService ]
+})
+
+export default definition

package/index.js

@@ -0,0 +1,11 @@
+import App from '@live-change/framework'
+const app = App.app()
+
+import definition from './definition.js'
+
+import "./interval.js"
+import "./schedule.js"
+import "./run.js"
+
+
+export default definition

package/interval.js

@@ -0,0 +1,163 @@
+import App from '@live-change/framework'
+const app = App.app()
+
+import definition from './definition.js'
+import config from './config.js'
+import { triggerType } from './run.js'
+
+export const Interval = definition.model({
+  name: "Interval",
+  propertyOfAny: {
+    to: ['owner', 'topic'],
+    ownerTypes: config.ownerTypes,
+    topicTypes: config.topicTypes,
+    writeAccessControl: {
+      roles: config.adminRoles
+    },
+    readAccessControl: {
+      roles: config.adminRoles
+    },
+    readAllAccess: ['admin'],
+  },
+  properties: {
+    description: {
+      type: String,
+      description: "Description of the interval"
+    },
+    interval: {
+      type: Number, // milliseconds      
+      description: "Interval between triggers in milliseconds"
+    },
+    wait: {
+      type: Number, // milliseconds 
+      description: "Wait for previous trigger to finish before planning next trigger"     
+    },
+    trigger: triggerType
+  }
+})
+
+async function processInterval({ id, interval, wait, trigger }) {
+  if(wait) await waitForTasks('cron_Interval', id)
+  const nextTimestamp = Date.now() + interval
+  const nextTime = new Date(nextTimestamp)
+  await triggerService({
+    service: 'timer',
+    type: 'createTimer',
+  }, {
+    timer: {
+      id: 'cron_Interval_' + id,
+      timestamp: nextTimestamp,
+      time: nextTime,      
+      service: definition.name,
+      causeType: 'cron_Interval',
+      cause: id,
+      trigger: {
+        type: 'runInterval',
+        data: {
+          interval: id
+        }
+      }
+    }
+  })
+}
+
+
+definition.trigger({
+  name: 'runInterval',
+  properties: {
+    interval: {
+      type: Interval,
+    }
+  },
+  execute: async ({ interval }, { service, trigger, triggerService }, emit) => {
+    const intervalData = await Interval.get(interval)
+    if(!intervalData) return /// interval was deleted
+    if(intervalData.wait) {
+      await runTrigger(intervalData.trigger, {
+        trigger,
+        triggerService,
+        jobType: 'cron_Interval',
+        job: interval,
+        timeout: Number.isInteger(intervalData.wait) ? intervalData.wait : undefined
+      })
+      await processInterval(intervalData)
+    } else {
+      await processInterval(intervalData) // no wait, process immediately
+      try {
+        await doRunTrigger(intervalData.trigger, {
+          trigger,
+          triggerService,
+          jobType: 'cron_Interval',
+          job: interval
+        })
+      } catch(error) {
+        console.error("ERROR RUNNING INTERVAL TRIGGER", error)
+      }
+    }
+  }
+})
+
+
+definition.trigger({
+  name: 'changeCron_Interval',
+  properties: {
+    object: {
+      type: Interval,
+      validation: ['nonEmpty'],
+    },
+    data: {
+      type: Object,
+    },
+    oldData: {
+      type: Object,
+    }
+  },
+  execute: async ({ object, data, oldData }, { service, trigger, triggerService }, emit) => {    
+    if(oldData) { // clear old version
+      await triggerService({
+        service: 'timer',
+        type: 'cancelTimerIfExists',
+        data: {
+          timer: 'cron_Interval_' + object.id
+        }
+      })
+      if(!data) { // full cleanup
+        await triggerService({
+          service: 'timer',
+          type: 'cancelTimerIfExists',
+          data: {
+            timer: 'cron_run_timeout_' + object.id
+          }
+        })
+        RunState.delete(App.encodeIdentifier(['cron_Interval', object.id]))
+      }
+    }
+    if(data) { // setup new version
+      await processInterval({
+        id: object,
+        ...data``
+      })
+    }
+  }
+})
+
+const Timer = definition.foreignModel('timer', 'Timer')
+
+definition.afterStart(async (service) => {
+  const position = ''
+  const bucketSize = 128
+  let bucket = []
+  do {
+    bucket = await Interval.rangeGet({
+      gt: position,
+      limit: bucketSize
+    })
+    for(const interval of bucket) {
+      const existingTimer = await Timer.get('cron_Interval_' + interval.id)
+      if(!existingTimer) {
+        console.error("INTERVAL", interval, "HAS NO TIMER, REPROCESSING")
+        await processInterval(interval)
+      }
+    }    
+  } while(bucket.length === bucketSize)    
+})

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@live-change/cron-service",
+  "version": "0.9.162",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "NODE_ENV=test tape tests/*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/live-change/live-change-stack.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/live-change/live-change-stack/issues"
+  },
+  "homepage": "https://github.com/live-change/live-change-stack",
+  "author": {
+    "email": "michal@laszczewski.pl",
+    "name": "Michał Łaszczewski",
+    "url": "https://www.viamage.com/"
+  },
+  "type": "module",
+  "dependencies": {
+    "@live-change/framework": "^0.9.162"
+  },
+  "gitHead": "59cd1485ca6d76bd87a6634a92d6e661e5803d5e"
+}

package/run.js

@@ -0,0 +1,204 @@
+import App from '@live-change/framework'
+const app = App.app()
+
+import definition from './definition.js'
+
+const Task = definition.foreignModel('task', 'Task')
+
+export const RunState = definition.model({
+  name: "RunState",
+  propertyOfAny: {
+    to: ['job'],
+    jobTypes: ['cron_Interval', 'cron_Schedule']
+  },
+  properties: {
+    state: {
+      type: String,
+      enum: ['running', 'waiting']
+    },
+    tasks: {
+      type: Array,
+      of: {
+        type: Task
+      }
+    },
+    startedAt: {
+      type: Date
+    },
+    returnTask: {
+      type: Boolean
+    }
+  },
+  indexes: {
+    byTasks: {
+      multi: true,
+      property: ['tasks']
+    }
+  }
+})
+
+
+export const triggerType = {  
+  description: "Trigger to schedule",
+  input: 'triggerEditor',
+  type: Object,
+  properties: {
+    name: {
+      description: "Trigger name",
+      type: String,
+    },
+    service: {
+      description: "Service holding the trigger, or null for triggering any service",
+      type: String,
+    },
+    properties: {
+      description: "Properties to pass to the trigger",
+      type: Object,      
+    }
+  }
+}
+
+export async function doRunTrigger(triggerInfo, { trigger, triggerService, jobType, job }) {
+  if(triggerInfo.service) {
+    return await triggerService({
+      type: triggerInfo.name,
+      service: triggerInfo.service,
+      causeType: jobType, cause: job
+    }, triggerInfo.properties, true)
+  } else {
+    return await trigger({
+      type: triggerInfo.name,
+      causeType: jobType, cause: job
+    }, triggerInfo.properties)
+  }
+}
+
+export async function runTrigger(triggerInfo, { trigger, triggerService, jobType, job, timeout }) {
+  const id = App.encodeIdentifier([jobType, job])
+  await RunState.create({    
+    id,
+    jobType, job,
+    startedAt: new Date(),
+    state: 'running'
+  })
+  if(timeout) {
+    const timestamp = Date.now() + timeout
+    const time = new Date(timestamp)
+    await triggerService({
+      service: 'timer',
+      type: 'createTimer'
+    }, {
+      timer: {
+        id: 'cron_run_timeout_' + id,
+        timestamp, time,
+        causeType: jobType, cause: job,
+        service: definition.name,
+        trigger: {
+          type: 'runTimeout',
+          data: {
+            jobType, job
+          }
+        }
+      }
+    })
+  }
+  let triggerResults = []
+  try {
+    triggerResults = await doRunTrigger(triggerInfo, { trigger, triggerService, jobType, job })
+  } 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)))
+      .filter(task => task !== undefined)
+      .filter(task => task.state !== 'done' && task.state !== 'failed')
+    if(tasks.length > 0) {
+      await RunState.update(id, {
+        state: 'waiting',
+        tasks: tasks.map(task => task.id)
+      })
+      /// Double check to avoid race condition
+/*       const runningTasks = await Promise.all(tasks.map(task => Task.get(task.id))).filter(task => task.state !== 'done' && task.state !== 'failed')
+      if(runningTasks.length === 0) {
+        await RunState.delete(id)    
+        return 'done'
+      } */
+      /// There are still running tasks, wait for them
+      return 'waiting'
+    }    
+  }   
+  await RunState.delete(id)
+  if(timeout) {
+    await triggerService({
+      service: 'timer',
+      type: 'cancelTimer'
+    }, {
+      timer: 'cron_run_timeout_' + id,
+    })
+  }
+  return 'done'
+}
+
+definition.trigger({
+  name: 'runTimeout',
+  properties: {
+    jobType: {
+      type: String
+    },
+    job: {
+      type: String
+    }
+  },
+  execute: async ({ jobType, job }, { trigger, triggerService }) => {
+    const id = App.encodeIdentifier([jobType, job])
+    await RunState.delete(id)
+    return 'done'
+  }
+})
+
+export async function waitForTasks(jobType, job) {
+  const runState = App.encodeIdentifier([jobType, job])
+  return new Promise((resolve, reject) => {    
+    let done = false    
+    const taskObservations = new Map()
+    function addTaskObservation(taskId) {
+      const observable = Task.observable(taskId)
+      if(!observable) return
+      const observer = {
+        set: (value) => {
+          if(!value) return updateTasks()
+          if(value.state === 'done' || value.state === 'failed') updateTasks()        
+        }
+      }
+      taskObservations.set(taskId, { observable, observer })
+      observable.observe(observer)
+    }
+    async function updateTasks() {
+      if(done) return
+      const runningTasks = taskObservations.values()
+        .filter(observation => observation.observable.getValue().state !== 'done' && observation.observable.getValue().state !== 'failed')
+      if(runningTasks.length === 0) {
+        await RunState.delete(runState) 
+        finish()
+      }
+    }
+    const runStateObservable = RunState.observable(runState)
+    const runStateObserver = {
+      set: (value) => {
+        if(!value) finish()
+        if(value.tasks) {
+          for(const taskId of value.tasks) {
+            addTaskObservation(taskId)
+          }
+        }
+      }
+    }
+    function finish() {
+      if(done) return
+      done = true
+      runStateObservable.unobserve(runStateObserver)
+      resolve()
+    }
+  })
+}

package/schedule.js

@@ -0,0 +1,176 @@
+import App from '@live-change/framework'
+const app = App.app()
+
+import definition from './definition.js'
+import config from './config.js'
+import { triggerType } from './run.js'
+
+export const Schedule = definition.model({
+  name: "Schedule",
+  propertyOfAny: {
+    to: ['owner', 'topic'],
+    ownerTypes: config.ownerTypes,
+    topicTypes: config.topicTypes,
+    writeAccessControl: {
+      roles: config.adminRoles
+    },
+    readAccessControl: {
+      roles: config.adminRoles
+    },
+    readAllAccess: ['admin'],
+  },
+  properties: {
+    description: {
+      type: String
+    },
+    minute: {
+      type: Number // NaN for every minute      
+    },
+    hour: {
+      type: Number, // NaN for every hour      
+    },
+    day: {
+      type: Number, // NaN for every day      
+    },
+    dayOfWeek: {
+      type: Number, // NaN for every day of week      
+    },
+    month: {
+      type: Number, // NaN for every month      
+    },
+    trigger: triggerType
+  }
+})
+
+function getNextTime(schedule) {
+  const now = new Date()
+  let time = now
+  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)
+    } else {
+      time = new Date(time.getFullYear(), time.getMonth(), time.getDate(), time.getHours(), schedule.minute, 0)
+    }
+  }
+  if(Number.isInteger(schedule.hour)) {
+    if(time.getHours() > schedule.hour) { // next day
+      time = new Date(time.getFullYear(), time.getMonth(), time.getDate() + 1, schedule.hour, schedule.minute || 0, 0)
+    } else {
+      time = new Date(time.getFullYear(), time.getMonth(), time.getDate(), schedule.hour, schedule.minute || 0, 0)
+    }
+  }
+
+  function isDayOk() {
+    if(Number.isInteger(schedule.month) && time.getMonth()+1 !== schedule.month) return false
+    if(Number.isInteger(schedule.day) && time.getDate() !== schedule.day) return false
+    if(Number.isInteger(schedule.dayOfWeek) && time.getDay()+1 !== schedule.dayOfWeek) return false        
+    return true
+  }
+  while(!isDayOk()) {
+    time = new Date(time.getTime() + 24 * 60 * 60 * 1000)
+  }
+  return time
+}
+
+async function processSchedule({ id, minute, hour, day, dayOfWeek, month, trigger }) {
+  const nextTime = getNextTime(schedule)
+  const nextTimestamp = nextTime.getTime()
+  await triggerService({
+    service: 'timer',
+    type: 'createTimer',
+  }, {
+    timer: {
+      id: 'cron_Schedule_' + id,
+      timestamp: nextTimestamp,
+      time: nextTime,      
+      service: definition.name,
+      causeType: 'cron_Schedule',
+      cause: id,
+      trigger: {
+        type: 'runSchedule',
+        data: {
+          schedule: id
+        }
+      }
+    }
+  })
+}
+
+definition.trigger({
+  name: 'runSchedule',
+  properties: {
+    schedule: {
+      type: Schedule,
+    }
+  },
+  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
+    try {
+      await doRunTrigger(scheduleData.trigger, {
+        trigger,
+        triggerService,
+        jobType: 'cron_Schedule',
+        job: schedule
+      })
+    } catch(error) {
+      console.error("ERROR RUNNING SCHEDULE TRIGGER", error)
+    }
+    
+  }
+})
+
+definition.trigger({
+  name: 'changeCron_Schedule',
+  properties: {
+    object: {
+      type: Schedule,
+      validation: ['nonEmpty'],
+    },
+    data: {
+      type: Object,
+    },
+    oldData: {
+      type: Object,
+    }
+  },
+  execute: async ({ object, data, oldData }, { service, trigger, triggerService }, emit) => {
+    if(oldData) {
+      await triggerService({
+        service: 'timer',
+        type: 'cancelTimerIfExists',
+        data: {
+          timer: 'cron_Schedule_' + object.id
+        }
+      })
+    }
+    if(data) {
+      await processSchedule({
+        id: object,
+        ...data
+      })
+    }
+  }
+})
+
+const Timer = definition.foreignModel('timer', 'Timer')
+
+definition.afterStart(async (service) => {
+  const position = ''
+  const bucketSize = 128
+  let bucket = []
+  do {
+    bucket = await Schedule.rangeGet({
+      gt: position,
+      limit: bucketSize
+    })
+  } while(bucket.length === bucketSize)
+  for(const schedule of bucket) {
+    const existingTimer = await Timer.get('cron_Schedule_' + schedule.id)
+    if(!existingTimer) {
+      console.error("SCHEDULE", schedule, "HAS NO TIMER, REPROCESSING")
+      await processSchedule(schedule)
+    }
+  }
+})