@sentio/runtime 2.59.0-rc.39 → 2.59.0-rc.40

package/src/service-worker.ts

@@ -1,26 +1,21 @@
 import {
-  DataBinding,
-  DBResponse,
   DeepPartial,
   Empty,
   ProcessConfigRequest,
-  ProcessConfigResponse,
-  ProcessResult,
+  ProcessStreamRequest,
   ProcessStreamResponse,
-  ProcessStreamResponse_Partitions,
   StartRequest
 } from '@sentio/protos'
 import { CallContext, ServerError, Status } from 'nice-grpc'
-import { PluginManager } from './plugin.js'
 import { errorString } from './utils.js'
 import { freezeGlobalConfig } from './global-config.js'
 import { DebugInfo, RichServerError } from 'nice-grpc-error-details'
-import { recordRuntimeInfo } from './service.js'
+import { ProcessorServiceImpl } from './service.js'
 import { BroadcastChannel, MessagePort, threadId } from 'worker_threads'
 import { Piscina } from 'piscina'
 import { configureEndpoints } from './endpoints.js'
 import { setupLogger } from './logger.js'
-import { AbstractStoreContext } from './db-context.js'
+import { Subject } from 'rxjs'
 
 let started = false
 
@@ -44,15 +39,7 @@ process
     console.info('Worker thread exiting, threadId:', threadId)
   })
 
-async function getConfig(request: ProcessConfigRequest, context?: CallContext): Promise<ProcessConfigResponse> {
-  if (!started) {
-    throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
-  }
-
-  const newConfig = ProcessConfigResponse.fromPartial({})
-  await PluginManager.INSTANCE.configure(newConfig)
-  return newConfig
-}
+let service: ProcessorServiceImpl | undefined
 
 const loader = async (options: any) => {
   if (options.target) {
@@ -64,9 +51,11 @@ const loader = async (options: any) => {
 
 const configureChannel = new BroadcastChannel('configure_channel')
 configureChannel.onmessage = (request: ProcessConfigRequest) => {
-  getConfig(request)
+  service?.getConfig(request, emptyCallContext)
 }
 
+const emptyCallContext = <CallContext>{}
+
 async function start(request: StartRequest, options: any): Promise<Empty> {
   if (started) {
     return {}
@@ -74,26 +63,24 @@ async function start(request: StartRequest, options: any): Promise<Empty> {
   freezeGlobalConfig()
 
   try {
-    await loader(options)
+    service = new ProcessorServiceImpl(() => loader(options), options)
   } catch (e) {
     throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))
   }
 
-  await PluginManager.INSTANCE.start(request)
+  await service.start(request, emptyCallContext)
   started = true
   return {}
 }
 
 export default async function ({
-  request,
   processId,
-  workerPort,
-  partition
+  request: firstRequest,
+  workerPort
 }: {
-  request: DataBinding
   processId: number
-  workerPort?: MessagePort
-  partition?: boolean
+  request: ProcessStreamRequest
+  workerPort: MessagePort
 }) {
   const { startRequest, configRequest, options } = Piscina.workerData
   if (!started) {
@@ -108,7 +95,7 @@ export default async function ({
     }
 
     if (configRequest) {
-      await getConfig(configRequest)
+      await service?.getConfig(configRequest, emptyCallContext)
       console.debug('worker', threadId, ' configured')
     }
   }
@@ -129,80 +116,20 @@ export default async function ({
     )
   }
 
-  console.debug('Worker', threadId, 'starting request ', processId)
-  const now = Date.now()
-  const timeoutPromise = new Promise((resolve, reject) => {
-    setTimeout(
-      () => {
-        reject(
-          new RichServerError(
-            Status.DEADLINE_EXCEEDED,
-            `Request ${processId} timed out after ${options['request-timeout']} ms`
-          )
-        )
-      },
-      (options['process-timeout'] ?? 60) * 1000
-    )
-  })
-  let resultPromise: Promise<ProcessResult | ProcessStreamResponse_Partitions>
-  if (partition) {
-    resultPromise = PluginManager.INSTANCE.partition(request)
-  } else {
-    resultPromise = PluginManager.INSTANCE.processBinding(
-      request,
-      undefined,
-      workerPort ? new WorkerStoreContext(workerPort, processId) : undefined
-    ).then((result) => {
-      recordRuntimeInfo(result, request.handlerType)
-      return result
+  await new Promise<void>((resolve) => {
+    const subject = new Subject<DeepPartial<ProcessStreamResponse>>()
+    subject.subscribe((resp: ProcessStreamResponse) => {
+      workerPort.postMessage(resp)
+      // receive the response from the processor , close and resolve the promise
+      if (resp.result) {
+        resolve()
+        workerPort.close()
+      }
     })
-  }
-
-  try {
-    const result = await Promise.race([resultPromise, timeoutPromise])
-    console.debug(
-      'worker',
-      threadId,
-      `finished ${partition ? 'partition' : 'process'} request`,
-      processId,
-      'took',
-      Date.now() - now
-    )
-    return result
-  } catch (e) {
-    console.error('worker', threadId, `failed ${partition ? 'partition' : 'process'} request`, processId, 'error:', e)
-    if (e instanceof RichServerError) {
-      throw e
-    } else {
-      throw new RichServerError(
-        Status.INTERNAL,
-        `Worker ${threadId} failed to process request ${processId}: ` + errorString(e),
-        [
-          DebugInfo.fromPartial({
-            detail: errorString(e),
-            stackEntries: e.stack?.split('\n')
-          })
-        ]
-      )
-    }
-  }
-}
-
-class WorkerStoreContext extends AbstractStoreContext {
-  constructor(
-    readonly port: MessagePort,
-    processId: number
-  ) {
-    super(processId)
-    this.port.on('message', (resp: DBResponse) => {
-      this.result(resp)
+    workerPort.on('message', (msg: ProcessStreamRequest) => {
+      const request = msg as ProcessStreamRequest
+      service?.handleRequest(request, firstRequest.binding, subject)
     })
-    this.port.on('close', () => {
-      this.close()
-    })
-  }
-
-  doSend(req: DeepPartial<ProcessStreamResponse>): void {
-    this.port.postMessage(req)
-  }
+    service?.handleRequest(firstRequest, firstRequest.binding, subject)
+  })
 }

package/src/service.ts

@@ -58,7 +58,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   private preparedData: PreparedData | undefined
   readonly enablePartition: boolean
 
-  constructor(loader: () => Promise<any>, shutdownHandler?: () => void) {
+  constructor(loader: () => Promise<any>, options?: any, shutdownHandler?: () => void) {
     this.loader = loader
     this.shutdownHandler = shutdownHandler
 
@@ -66,7 +66,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       ? process.env['ENABLE_PREPROCESS'].toLowerCase() == 'true'
       : false
 
-    this.enablePartition = process.env['SENTIO_ENABLE_BINDING_DATA_PARTITION'] == 'true'
+    this.enablePartition = options?.['enable-partition'] == true
   }
 
   async getConfig(request: ProcessConfigRequest, context: CallContext): Promise<ProcessConfigResponse> {
@@ -416,58 +416,20 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     yield* from(subject).pipe(withAbort(context.signal))
   }
 
+  private dbContexts = new Contexts()
+
   protected async handleRequests(
     requests: AsyncIterable<ProcessStreamRequest>,
     subject: Subject<DeepPartial<ProcessStreamResponse>>
   ) {
-    const contexts = new Contexts()
     let lastBinding: DataBinding | undefined = undefined
     for await (const request of requests) {
       try {
         // console.log('received request:', request, 'lastBinding:', lastBinding)
         if (request.binding) {
-          process_binding_count.add(1)
-
-          // Adjust binding will make some request become invalid by setting UNKNOWN HandlerType
-          // for older SDK version, so we just return empty result for them here
-          if (request.binding.handlerType === HandlerType.UNKNOWN) {
-            subject.next({
-              processId: request.processId,
-              result: ProcessResult.create()
-            })
-            continue
-          }
           lastBinding = request.binding
-
-          if (this.enablePartition) {
-            PluginManager.INSTANCE.partition(request.binding).then((partitions) => {
-              subject.next({
-                processId: request.processId,
-                partitions
-              })
-            })
-          } else {
-            this.startProcess(request.processId, request.binding, contexts, subject)
-          }
-        }
-
-        if (request.start) {
-          if (!lastBinding) {
-            console.error('start request received without binding')
-            subject.error(new Error('start request received without binding'))
-            continue
-          }
-          this.startProcess(request.processId, lastBinding, contexts, subject)
-        }
-
-        if (request.dbResult) {
-          const dbContext = contexts.get(request.processId)
-          try {
-            dbContext?.result(request.dbResult)
-          } catch (e) {
-            subject.error(new Error('db result error, process should stop'))
-          }
         }
+        this.handleRequest(request, lastBinding, subject)
       } catch (e) {
         // should not happen
         console.error('unexpect error during handle loop', e)
@@ -475,13 +437,62 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     }
   }
 
-  private startProcess(
-    processId: number,
-    binding: DataBinding,
-    contexts: Contexts,
+  async handleRequest(
+    request: ProcessStreamRequest,
+    lastBinding: DataBinding | undefined,
     subject: Subject<DeepPartial<ProcessStreamResponse>>
   ) {
-    const dbContext = contexts.new(processId, subject)
+    if (request.binding) {
+      process_binding_count.add(1)
+
+      // Adjust binding will make some request become invalid by setting UNKNOWN HandlerType
+      // for older SDK version, so we just return empty result for them here
+      if (request.binding.handlerType === HandlerType.UNKNOWN) {
+        subject.next({
+          processId: request.processId,
+          result: ProcessResult.create()
+        })
+        return
+      }
+
+      if (this.enablePartition) {
+        try {
+          const partitions = await PluginManager.INSTANCE.partition(request.binding)
+          subject.next({
+            processId: request.processId,
+            partitions
+          })
+        } catch (e) {
+          console.error('Partition error:', e)
+          subject.error(new Error('Partition error: ' + errorString(e)))
+          return
+        }
+      } else {
+        this.startProcess(request.processId, request.binding, subject)
+      }
+    }
+
+    if (request.start) {
+      if (!lastBinding) {
+        console.error('start request received without binding')
+        subject.error(new Error('start request received without binding'))
+        return
+      }
+      this.startProcess(request.processId, lastBinding, subject)
+    }
+
+    if (request.dbResult) {
+      const dbContext = this.dbContexts.get(request.processId)
+      try {
+        dbContext?.result(request.dbResult)
+      } catch (e) {
+        subject.error(new Error('db result error, process should stop'))
+      }
+    }
+  }
+
+  private startProcess(processId: number, binding: DataBinding, subject: Subject<DeepPartial<ProcessStreamResponse>>) {
+    const dbContext = this.dbContexts.new(processId, subject)
     const start = Date.now()
     PluginManager.INSTANCE.processBinding(binding, this.preparedData, dbContext)
       .then(async (result) => {
@@ -501,7 +512,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       .finally(() => {
         const cost = Date.now() - start
         process_binding_time.add(cost)
-        contexts.delete(processId)
+        this.dbContexts.delete(processId)
       })
   }
 }