@live-change/task-service 0.9.106 → 0.9.108

package/model.js

@@ -19,6 +19,9 @@ const taskProperties = {
   properties: {
     type: Object
   },
+  client: {
+    type: Object,
+  },
   result: {
     type: Object
   },
@@ -96,6 +99,9 @@ const Task = definition.model({
     byCauseAndState: {
       property: ['causeType', 'cause', 'state']
     },
+    byCauseAndStart: {
+      property: ['causeType', 'cause', 'startedAt']
+    },
     byState: {
       property: ['state']
     },
@@ -182,7 +188,7 @@ const Task = definition.model({
       function: async function(input, output, { tableName }) {
         function mapFunction(obj) {
           if(!obj) return null
-          if(['done', 'failed', 'canceled'].includes(obj.state)) return null
+          if(['done', 'failed', 'canceled', 'fallbackDone'].includes(obj.state)) return null
           if(obj.causeType === tableName) return null
           return { id: `"${obj.name}"_${obj.id}`, to: obj.id }
         }
@@ -259,6 +265,31 @@ definition.view({
   }
 })
 
+definition.view({
+  name: 'tasksByCauseAndStart',
+  internal: true,
+  properties: {
+    causeType: {
+      type: String
+    },
+    cause: {
+      type: String
+    },
+    ...App.rangeProperties
+  },
+  returns: {
+    type: Array,
+    of: {
+      type: Task
+    }
+  },
+  async daoPath(props) {
+    const { causeType, cause } = props
+    const range = App.extractRange(props)
+    return Task.sortedIndexRangePath('byCauseAndStart', [causeType, cause], range)
+  }
+})
+
 definition.view({
   name: 'tasksByRoot',
   properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/task-service",
-  "version": "0.9.106",
+  "version": "0.9.108",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -22,8 +22,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@live-change/framework": "^0.9.106",
-    "@live-change/relations-plugin": "^0.9.106"
+    "@live-change/framework": "^0.9.108",
+    "@live-change/relations-plugin": "^0.9.108"
   },
-  "gitHead": "1afc853b9044a57046dae972df68d89c8c1cd1a6"
+  "gitHead": "c500fad0c238b17fa816248f16e9e9692abea569"
 }

package/task.ts

@@ -36,11 +36,17 @@ async function triggerOnTaskStateChange(taskObject, causeType, cause) {
   })
 }
 
-async function createOrReuseTask(taskDefinition, props, causeType, cause, expire) {
+interface ClientInfo {
+    user?: string
+    session?: string
+}
+
+async function createOrReuseTask(taskDefinition, props, causeType, cause, expire, client:ClientInfo) {  
   const propertiesJson = JSON.stringify(props)
+  const userInfo = client?.user ? `user:${client.user}` : `session:${client?.session}`
   const hash = crypto
     .createHash('sha256')
-    .update(taskDefinition.name + ':' + propertiesJson)
+    .update(taskDefinition.name + ':' + propertiesJson + userInfo)    
     .digest('hex')
 
   const expireDate = (expire ?? taskDefinition.expire) ? new Date(Date.now() - taskDefinition.expire) : null
@@ -66,7 +72,8 @@ async function createOrReuseTask(taskDefinition, props, causeType, cause, expire
       state: 'created',
       service: taskDefinition.service,
       retries: [],
-      maxRetries: taskDefinition.maxRetries ?? 5
+      maxRetries: taskDefinition.maxRetries ?? 5,
+      client
     }
 
   if(!oldTask) {
@@ -82,12 +89,13 @@ async function createOrReuseTask(taskDefinition, props, causeType, cause, expire
   return taskObject
 }
 
-async function startTask(taskFunction, props, causeType, cause, expire){
-  const taskObject = await createOrReuseTask(taskFunction.definition, props, causeType, cause, expire)
+async function startTask(taskFunction, props, causeType, cause, expire, client:ClientInfo){
+  const taskObject = await createOrReuseTask(taskFunction.definition, props, causeType, cause, expire, client)
   const context = {
     causeType,
     cause,
     taskObject,
+    client
   }
   console.log("START TASK!", taskFunction.name)
   const promise = taskFunction(props, context)
@@ -181,6 +189,34 @@ interface TaskDefinition {
 
 }
 
+function progressCounter(reportProgress) {  
+  let currentAcc = 0
+  let totalAcc = 0
+  const progressFunction = (current, total, action, opts) => {
+    currentAcc = current
+    totalAcc = total
+    reportProgress(currentAcc, totalAcc, action, opts)
+  }
+  progressFunction.increment = (action, by = 1, opts) => {
+    currentAcc += by
+    progressFunction(currentAcc, totalAcc, action, opts)
+  }
+  progressFunction.incrementTotal = (action, by = 1, opts) => {
+    totalAcc += by
+    progressFunction(currentAcc, totalAcc, action, opts)
+  }
+  progressFunction.slice = (sliceSize, factor = 1.0) => {
+    const sliceStart = currentAcc    
+    const sliceEnd = sliceStart + sliceSize
+    currentAcc = sliceEnd
+    return progressCounter((current, total, action, opts) => {
+      progressFunction(sliceStart + Math.min(current, sliceSize) * factor,
+         sliceEnd + Math.min(total, sliceSize) * factor, action, opts)
+    })
+  }
+  return progressFunction
+}
+
 type TaskFunction = (props, context: TaskExecuteContext, emit, reportProgress) => Promise<any>
 
 export default function task(definition:TaskDefinition, serviceDefinition) {
@@ -196,7 +232,7 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
     }
 
     let taskObject = context.taskObject ?? 
-      await createOrReuseTask(definition, props, context.causeType, context.cause, context.expire)
+      await createOrReuseTask(definition, props, context.causeType, context.cause, context.expire, context.client)
 
     if(!taskObject?.state) throw new Error('Task object state is not defined in ' + taskObject)
     if(!taskObject?.id) throw new Error('Task object id is not defined in '+taskObject)
@@ -258,60 +294,65 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
         startedAt: new Date()
       })
       await triggerOnTaskStateChange(taskObject, context.causeType, context.cause)
+      const commonFunctions = {
+        async run(taskFunction: TaskFunction, props, progressFactor = 1, expire = undefined) {
+          if(typeof taskFunction !== 'function') {
+            console.log("TASK FUNCTION", taskFunction)
+            throw new Error('Task function is not a function')
+          }
+          //console.log("SUBTASK RUN", taskFunction.definition.name, props)
+          const subtaskProgress = { current: 0, total: 1, factor: progressFactor }
+          subtasksProgress.push(subtaskProgress)
+          try {
+            const result = await taskFunction(
+              props,
+              {
+                ...context,
+                taskObject: undefined,
+                causeType: 'task_Task',
+                cause: taskObject.id,
+                expire
+              },
+              (events) => app.emitEvents(serviceDefinition.name,
+                Array.isArray(events) ? events : [events], {}),
+              (current, total, action) => {
+                subtaskProgress.current = current
+                subtaskProgress.total = total
+                updateProgress()
+              }
+            )
+            //console.log("SUBTASK DONE", taskFunction.definition.name, props, '=>', result)
+            subtaskProgress.current = subtaskProgress.total
+            updateProgress()
+            return result
+          } catch(error) {
+            subtaskProgress.current = subtaskProgress.total // failed = finished
+            const outputError: any = new Error("Subtask error: " + error.toString())
+            outputError.stack = error.stack
+            outputError.taskNoRetry = true
+            throw outputError
+          }
+        },
+        progress: progressCounter((current, total, action, opts) => { // throttle this
+          selfProgress = {
+            ...opts,
+            current, total, action
+          }
+          updateProgress()
+        })
+      }
       const runContext = {
         ...context,
         task: {
           id: taskObject.id,
-          async run(taskFunction: TaskFunction, props, progressFactor = 1, expire = undefined) {
-            if(typeof taskFunction !== 'function') {
-              console.log("TASK FUNCTION", taskFunction)
-              throw new Error('Task function is not a function')
-            }
-            //console.log("SUBTASK RUN", taskFunction.definition.name, props)
-            const subtaskProgress = { current: 0, total: 1, factor: progressFactor }
-            subtasksProgress.push(subtaskProgress)
-            try {
-              const result = await taskFunction(
-                props,
-                {
-                  ...context,
-                  taskObject: undefined,
-                  causeType: 'task_Task',
-                  cause: taskObject.id,
-                  expire
-                },
-                (events) => app.emitEvents(serviceDefinition.name,
-                  Array.isArray(events) ? events : [events], {}),
-                (current, total, action) => {
-                  subtaskProgress.current = current
-                  subtaskProgress.total = total
-                  updateProgress()
-                }
-              )
-              //console.log("SUBTASK DONE", taskFunction.definition.name, props, '=>', result)
-              subtaskProgress.current = subtaskProgress.total
-              updateProgress()
-              return result
-            } catch(error) {
-              subtaskProgress.current = subtaskProgress.total // failed = finished
-              const outputError: any = new Error("Subtask error: " + error.toString())
-              outputError.stack = error.stack
-              outputError.taskNoRetry = true
-              throw outputError
-            }
-          },
-          async progress(current, total, action, opts) { // throttle this
-            selfProgress = {
-              ...opts,
-              current, total, action
-            }
-            updateProgress()
-          }
-        },
+          ...commonFunctions
+        },      
+        ...commonFunctions,
         async trigger(trigger, props) {
           return await app.trigger({
             causeType: 'task_Task',
             cause: taskObject.id,
+            client: context.client,
             ...trigger,
           }, props)
         },
@@ -319,6 +360,7 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
           return await app.triggerService({
             causeType: 'task_Task',
             cause: taskObject.id,
+            client: context.client,
             ...trigger
           }, props, returnArray)
         },
@@ -326,6 +368,7 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
           const tasks = await app.trigger({
             causeType: 'task_Task',
             cause: taskObject.id,
+            client: context.client,
             ...trigger
           }, data)
           const fullProgressSum = tasks.length * progressFactor     
@@ -374,7 +417,7 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
             //console.log("TASK WATCHERS PROMISES FULLFILLED", taskWatchers)
             const results = taskWatchers.map(watcher => {
               //console.log("WATCHER OBSERVABLE", watcher.observable)
-              watcher.observable.getValue().result
+              return watcher.observable.getValue().result
             })
             return results
           } catch(subtask) {
@@ -447,17 +490,17 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
       }
     }
 
-    while(taskObject.state !== 'done' && taskObject.state !== 'failed') {
+    if(taskObject.state === 'failed') {
+      throw new Error(taskObject.retries[taskObject.retries.length - 1].error)
+    }
+    
+    while(taskObject.state !== 'done' && taskObject.state !== 'fallbackDone' && taskObject.state !== 'failed') {
       console.log("RUNNING TASK", definition.name, "STATE", taskObject.state, "OBJECT", taskObject)
       await runTask()
       console.log("TASK", definition.name, "AFTER RUNTASK", taskObject)
      // console.log("TASK", definition.name, "AFTER RUNTASK", taskObject)
     }
 
-    if(taskObject.state === 'failed') {
-      throw new Error(taskObject.retries[taskObject.retries.length - 1].error)
-    }
-
     return taskObject.result
   }
 
@@ -481,6 +524,7 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
             causeType: task.causeType,
             cause: task.cause,
             taskObject,
+            client: task.client
           }
           /// mark started subtasks as interrupted
           const subtasks = await app.serviceViewGet('task', 'tasksByRoot', {
@@ -526,10 +570,10 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
       },
       async execute(props, context, emit) {
         const startResult =
-          await startTask(taskFunction, props, 
+          await startTask(taskFunction, props,            
             context.reaction.causeType ?? 'trigger', 
             context.reaction.cause ?? context.reaction.id, 
-            props.taskExpire) // Must be done that way, so subtasks can be connected to the parent task
+            props.taskExpire, context.client) // Must be done that way, so subtasks can be connected to the parent task
         return startResult.task
       }
     })
@@ -543,10 +587,11 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
       },
       async execute(props, context, emit) {
         const startResult =
-          await startTask(taskFunction, props, 
+          await startTask(taskFunction, 
+            props,
             context.reaction.causeType ?? 'trigger', 
             context.reaction.cause ?? context.reaction.id, 
-            props.taskExpire) // Must be done that way, so subtasks can be connected to the parent task
+            props.taskExpire, context.client) // Must be done that way, so subtasks can be connected to the parent task
         return startResult.task
       }
     })  
@@ -562,23 +607,18 @@ export default function task(definition:TaskDefinition, serviceDefinition) {
         type: Task
       },
       async execute(props, context, emit) {
-        const client = {
-          ...context.client,
-          sessionKey: undefined
-        }
         const startResult =
-          await startTask(taskFunction, { ...props, client }, 'command', context.command.id, undefined)
+          await startTask(taskFunction, props, 'command', context.command.id, undefined, context.client)
         return startResult.task
       },
       ...(typeof definition.action === 'object' && definition.action)
     })
 
-
   }
 
   taskFunction.definition = definition
-  taskFunction.start = async (props, causeType, cause, expire = undefined) => {
-    return await startTask(taskFunction, props, causeType, cause, expire)
+  taskFunction.start = async (props, causeType, cause, expire = undefined, client:ClientInfo) => {
+    return await startTask(taskFunction, props, causeType, cause, expire, client)
   }
   return taskFunction