@sentio/runtime 2.57.12-rc.j → 2.57.13-rc.1

package/src/service-manager.ts

@@ -1,35 +1,27 @@
-import { CallContext, ServerError, Status } from 'nice-grpc'
-import { DebugInfo, RichServerError } from 'nice-grpc-error-details'
-import { from } from 'ix/Ix.asynciterable'
-import { withAbort } from 'ix/Ix.asynciterable.operators'
+import { CallContext } from 'nice-grpc'
 import { Piscina } from 'piscina'
-
 import {
   DataBinding,
+  DBRequest,
+  DBResponse,
   DeepPartial,
   Empty,
   HandlerType,
-  PreparedData,
-  PreprocessStreamRequest,
-  ProcessBindingResponse,
-  ProcessBindingsRequest,
   ProcessConfigRequest,
   ProcessConfigResponse,
-  ProcessorServiceImplementation,
   ProcessResult,
   ProcessStreamRequest,
   ProcessStreamResponse,
   StartRequest
 } from '@sentio/protos'
 
-import { PluginManager } from './plugin.js'
-import { errorString, mergeProcessResults } from './utils.js'
-import { GLOBAL_CONFIG } from './global-config.js'
-
-import { StoreContext } from './db-context.js'
+import { IStoreContext } from './db-context.js'
 import { Subject } from 'rxjs'
 
 import { processMetrics } from './metrics.js'
+import { MessageChannel } from 'node:worker_threads'
+import { ProcessorServiceImpl } from './service.js'
+import { TemplateInstanceState } from './state.js'
 
 const { process_binding_count, process_binding_time, process_binding_error } = processMetrics
 
@@ -37,152 +29,64 @@ const { process_binding_count, process_binding_time, process_binding_error } = p
   return this.toString()
 }
 
-export class ServiceManager implements ProcessorServiceImplementation {
-  private started = false
-  // When there is unhandled error, stop process and return unavailable error
-  unhandled: Error
-  // private processorConfig: ProcessConfigResponse
+export class ServiceManager extends ProcessorServiceImpl {
   private pool: Piscina<any, any>
-
   private workerData: any = {}
 
   constructor(
     readonly options: any,
-    readonly loader: () => Promise<any>,
-    readonly shutdownHandler?: () => void
+    loader: () => Promise<any>,
+    shutdownHandler?: () => void
   ) {
+    super(loader, shutdownHandler)
     this.workerData.options = options
   }
 
-  async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: CallContext) {
-    throw new Error('not supported')
-  }
-
   async getConfig(request: ProcessConfigRequest, context: CallContext): Promise<ProcessConfigResponse> {
-    if (!this.started) {
-      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
-    }
+    const newConfig = await super.getConfig(request, context)
 
-    // broadcast to all worker
-    const bc = new BroadcastChannel('configure_channel')
-    bc.postMessage(request)
-
-    // also configure the main thread
-    const newConfig = ProcessConfigResponse.fromPartial({})
-    await PluginManager.INSTANCE.configure(newConfig)
+    // check if templateInstances changed
+    if (newConfig.templateInstances?.length != this.workerData?.configRequest?.templateInstances?.length) {
+      this.workerData.startRequest = StartRequest.fromPartial({
+        templateInstances: newConfig.templateInstances
+      })
+    }
 
     this.workerData.configRequest = request
+
+    // if pool is initialized, this will trigger restart of all workers
+    await this.initPool()
     return newConfig
   }
 
   async start(request: StartRequest, context: CallContext): Promise<Empty> {
-    if (this.started) {
-      return {}
-    }
-
-    try {
-      await this.loader()
-    } catch (e) {
-      throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))
-    }
-
-    // also start the processor in main thread
-    await PluginManager.INSTANCE.start(request)
-    this.started = true
+    await super.start(request, context)
     this.workerData.startRequest = request
     return {}
   }
 
   async stop(request: Empty, context: CallContext): Promise<Empty> {
-    await this.pool.destroy()
-    if (this.shutdownHandler) {
-      console.log('Server Shutting down in 5 seconds')
-      setTimeout(this.shutdownHandler, 5000)
-    }
-    return {}
+    await this.pool?.destroy()
+    return await super.stop(request, context)
   }
 
-  async processBindings(request: ProcessBindingsRequest, options?: CallContext): Promise<ProcessBindingResponse> {
-    const promises = []
-    for (const binding of request.bindings) {
-      const promise = this.processBinding(binding)
-      if (GLOBAL_CONFIG.execution.sequential) {
-        await promise
-      }
-      promises.push(promise)
-    }
-    let promise
-    try {
-      promise = await Promise.all(promises)
-      processMetrics.process_binding_count.add(request.bindings.length)
-    } catch (e) {
-      processMetrics.process_binding_error.add(request.bindings.length)
-      throw e
-    }
-    const result = mergeProcessResults(promise)
-
-    // let updated = false
-    // if (PluginManager.INSTANCE.stateDiff(this.processorConfig)) {
-    //   await this.configure()
-    //   updated = true
-    // }
-
-    return {
-      result
-    }
-  }
-
-  async processBinding(request: DataBinding): Promise<ProcessResult> {
-    if (!this.started) {
-      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
-    }
+  async process(request: DataBinding, dbContext?: ChannelStoreContext): Promise<ProcessResult> {
     if (!this.pool) {
-      this.pool = new Piscina({
-        maxThreads: this.options.worker,
-        minThreads: this.options.worker,
-        filename: new URL('./service-worker.js', import.meta.url).href.replaceAll('runtime/src', 'runtime/lib'),
-        argv: process.argv,
-        workerData: this.workerData
-      })
-    }
-    if (this.unhandled) {
-      throw new RichServerError(
-        Status.UNAVAILABLE,
-        'Unhandled exception/rejection in previous request: ' + errorString(this.unhandled),
-        [
-          DebugInfo.fromPartial({
-            detail: this.unhandled.message,
-            stackEntries: this.unhandled.stack?.split('\n')
-          })
-        ]
-      )
+      await this.initPool()
     }
 
-    return this.pool.run({ request })
+    return this.pool.run(
+      { request, workerPort: dbContext?.workerPort },
+      { transferList: dbContext?.workerPort ? [dbContext?.workerPort] : [] }
+    )
   }
 
-  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
-    if (!this.started) {
-      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
-    }
+  private readonly contexts = new Contexts()
 
-    const subject = new Subject<DeepPartial<ProcessStreamResponse>>()
-    this.handleRequests(requests, subject)
-      .then(() => {
-        subject.complete()
-      })
-      .catch((e) => {
-        console.error(e)
-        subject.error(e)
-      })
-    yield* from(subject).pipe(withAbort(context.signal))
-  }
-
-  private async handleRequests(
+  protected async handleRequests(
     requests: AsyncIterable<ProcessStreamRequest>,
     subject: Subject<DeepPartial<ProcessStreamResponse>>
   ) {
-    const contexts = new Contexts()
     for await (const request of requests) {
       try {
         // console.debug('received request:', request)
@@ -200,13 +104,12 @@ export class ServiceManager implements ProcessorServiceImplementation {
           }
 
           const binding = request.binding
-          // todo support db request
-          const dbContext = contexts.new(request.processId, subject)
+
+          const dbContext = this.contexts.new(request.processId, subject)
+
           const start = Date.now()
-          await this.processBinding(binding)
+          await this.process(binding, dbContext)
             .then(async (result) => {
-              // await all pending db requests
-              // await dbContext.awaitPendings()
               subject.next({
                 result,
                 processId: request.processId
@@ -219,11 +122,11 @@ export class ServiceManager implements ProcessorServiceImplementation {
             .finally(() => {
               const cost = Date.now() - start
               process_binding_time.add(cost)
-              contexts.delete(request.processId)
+              this.contexts.delete(request.processId)
             })
         }
         if (request.dbResult) {
-          const dbContext = contexts.get(request.processId)
+          const dbContext = this.contexts.get(request.processId)
           try {
             dbContext?.result(request.dbResult)
           } catch (e) {
@@ -236,17 +139,38 @@ export class ServiceManager implements ProcessorServiceImplementation {
       }
     }
   }
+
+  private async initPool() {
+    if (this.pool) {
+      await this.pool.close()
+    }
+    this.pool = new Piscina({
+      maxThreads: this.options.worker,
+      minThreads: this.options.worker,
+      filename: new URL('./service-worker.js', import.meta.url).href.replaceAll('runtime/src', 'runtime/lib'),
+      argv: process.argv,
+      workerData: this.workerData
+    })
+    this.pool.on('message', (msg) => {
+      if (msg.event == 'add_template_instance') {
+        // sync the template state from worker to the main thread
+        TemplateInstanceState.INSTANCE.addValue(msg.value)
+      }
+    })
+  }
 }
 
+export type WorkerMessage = DBRequest & { processId: number }
+
 class Contexts {
-  private contexts: Map<number, StoreContext> = new Map()
+  private contexts: Map<number, ChannelStoreContext> = new Map()
 
   get(processId: number) {
     return this.contexts.get(processId)
   }
 
   new(processId: number, subject: Subject<DeepPartial<ProcessStreamResponse>>) {
-    const context = new StoreContext(subject, processId)
+    const context = new ChannelStoreContext(subject, processId)
     this.contexts.set(processId, context)
     return context
   }
@@ -257,3 +181,52 @@ class Contexts {
     this.contexts.delete(processId)
   }
 }
+
+export class ChannelStoreContext implements IStoreContext {
+  channel = new MessageChannel()
+
+  constructor(
+    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
+    readonly processId: number
+  ) {
+    this.mainPort.on('message', (req: ProcessStreamRequest) => {
+      subject.next({
+        ...req,
+        processId: processId
+      })
+    })
+  }
+
+  sendRequest(request: DeepPartial<Omit<DBRequest, 'opId'>>, timeoutSecs?: number): Promise<DBResponse> {
+    throw new Error('should not be used on main thread')
+  }
+
+  get workerPort() {
+    return this.channel.port2
+  }
+
+  get mainPort() {
+    return this.channel.port1
+  }
+
+  result(dbResult: DBResponse) {
+    this.mainPort.postMessage(dbResult)
+  }
+
+  close(): void {
+    this.mainPort.close()
+  }
+
+  error(processId: number, e: any): void {
+    console.error('process error', processId, e)
+    const errorResult = ProcessResult.create({
+      states: {
+        error: e?.toString()
+      }
+    })
+    this.subject.next({
+      result: errorResult,
+      processId
+    })
+  }
+}

package/src/service-worker.ts

@@ -1,13 +1,24 @@
-import { DataBinding, Empty, ProcessConfigRequest, ProcessConfigResponse, StartRequest } from '@sentio/protos'
+import {
+  DataBinding,
+  DBResponse,
+  DeepPartial,
+  Empty,
+  ProcessConfigRequest,
+  ProcessConfigResponse,
+  ProcessStreamResponse,
+  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 { BroadcastChannel } from 'worker_threads'
+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'
 
 let started = false
 
@@ -68,14 +79,25 @@ async function start(request: StartRequest, options: any): Promise<Empty> {
   return {}
 }
 
-export default async function ({ request }: { request: DataBinding }) {
+export default async function ({
+  request,
+  processId,
+  workerPort
+}: {
+  request: DataBinding
+  processId: number
+  workerPort?: MessagePort
+}) {
   const { startRequest, configRequest, options } = Piscina.workerData
   if (!started) {
+    const logLevel = process.env['LOG_LEVEL']?.toUpperCase()
+    setupLogger(options['log-format'] === 'json', logLevel === 'debug' ? true : options.debug, threadId)
+
     configureEndpoints(options)
 
     if (startRequest) {
       await start(startRequest, options)
-      console.debug('worker started')
+      console.debug('worker started, template instance:', startRequest.templateInstances?.length)
     }
 
     if (configRequest) {
@@ -85,13 +107,15 @@ export default async function ({ request }: { request: DataBinding }) {
   }
 
   if (unhandled) {
+    const err = unhandled
+    unhandled = undefined
     throw new RichServerError(
       Status.UNAVAILABLE,
-      'Unhandled exception/rejection in previous request: ' + errorString(unhandled),
+      'Unhandled exception/rejection in previous request: ' + errorString(err),
       [
         DebugInfo.fromPartial({
-          detail: unhandled.message,
-          stackEntries: unhandled.stack?.split('\n')
+          detail: err.message,
+          stackEntries: err.stack?.split('\n')
         })
       ]
     )
@@ -99,9 +123,28 @@ export default async function ({ request }: { request: DataBinding }) {
 
   const result = await PluginManager.INSTANCE.processBinding(
     request,
-    undefined
-    // PluginManager.INSTANCE.dbContextLocalStorage.getStore()
+    undefined,
+    workerPort ? new WorkerStoreContext(workerPort, processId) : undefined
   )
   recordRuntimeInfo(result, request.handlerType)
   return result
 }
+
+class WorkerStoreContext extends AbstractStoreContext {
+  constructor(
+    readonly port: MessagePort,
+    processId: number
+  ) {
+    super(processId)
+    this.port.on('message', (resp: DBResponse) => {
+      this.result(resp)
+    })
+    this.port.on('close', () => {
+      this.close()
+    })
+  }
+
+  doSend(req: DeepPartial<ProcessStreamResponse>): void {
+    this.port.postMessage(req)
+  }
+}

package/src/service.ts

@@ -413,7 +413,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     yield* from(subject).pipe(withAbort(context.signal))
   }
 
-  private async handleRequests(
+  protected async handleRequests(
     requests: AsyncIterable<ProcessStreamRequest>,
     subject: Subject<DeepPartial<ProcessStreamResponse>>
   ) {

package/src/state.ts

@@ -1,3 +1,6 @@
+import { TemplateInstance } from '@sentio/protos'
+import { isMainThread, parentPort, threadId } from 'node:worker_threads'
+
 export class State {
   stateMap = new Map<string, any>()
 
@@ -81,3 +84,19 @@ export abstract class ListStateStorage<T> extends StateStorage<T[]> {
     return value
   }
 }
+
+export class TemplateInstanceState extends ListStateStorage<TemplateInstance> {
+  static INSTANCE = new TemplateInstanceState()
+
+  constructor() {
+    super()
+  }
+
+  override addValue(value: TemplateInstance): TemplateInstance {
+    if (!isMainThread) {
+      // I'm worker thread, should notice the main thread
+      parentPort?.postMessage({ event: 'add_template_instance', value, from: threadId })
+    }
+    return super.addValue(value)
+  }
+}