@sentio/runtime 2.57.12 → 2.57.13-rc.1

package/src/service-manager.ts

@@ -0,0 +1,232 @@
+import { CallContext } from 'nice-grpc'
+import { Piscina } from 'piscina'
+import {
+  DataBinding,
+  DBRequest,
+  DBResponse,
+  DeepPartial,
+  Empty,
+  HandlerType,
+  ProcessConfigRequest,
+  ProcessConfigResponse,
+  ProcessResult,
+  ProcessStreamRequest,
+  ProcessStreamResponse,
+  StartRequest
+} from '@sentio/protos'
+
+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
+
+;(BigInt.prototype as any).toJSON = function () {
+  return this.toString()
+}
+
+export class ServiceManager extends ProcessorServiceImpl {
+  private pool: Piscina<any, any>
+  private workerData: any = {}
+
+  constructor(
+    readonly options: any,
+    loader: () => Promise<any>,
+    shutdownHandler?: () => void
+  ) {
+    super(loader, shutdownHandler)
+    this.workerData.options = options
+  }
+
+  async getConfig(request: ProcessConfigRequest, context: CallContext): Promise<ProcessConfigResponse> {
+    const newConfig = await super.getConfig(request, context)
+
+    // 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> {
+    await super.start(request, context)
+    this.workerData.startRequest = request
+    return {}
+  }
+
+  async stop(request: Empty, context: CallContext): Promise<Empty> {
+    await this.pool?.destroy()
+    return await super.stop(request, context)
+  }
+
+  async process(request: DataBinding, dbContext?: ChannelStoreContext): Promise<ProcessResult> {
+    if (!this.pool) {
+      await this.initPool()
+    }
+
+    return this.pool.run(
+      { request, workerPort: dbContext?.workerPort },
+      { transferList: dbContext?.workerPort ? [dbContext?.workerPort] : [] }
+    )
+  }
+
+  private readonly contexts = new Contexts()
+
+  protected async handleRequests(
+    requests: AsyncIterable<ProcessStreamRequest>,
+    subject: Subject<DeepPartial<ProcessStreamResponse>>
+  ) {
+    for await (const request of requests) {
+      try {
+        // console.debug('received request:', request)
+        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
+          }
+
+          const binding = request.binding
+
+          const dbContext = this.contexts.new(request.processId, subject)
+
+          const start = Date.now()
+          await this.process(binding, dbContext)
+            .then(async (result) => {
+              subject.next({
+                result,
+                processId: request.processId
+              })
+            })
+            .catch((e) => {
+              dbContext.error(request.processId, e)
+              process_binding_error.add(1)
+            })
+            .finally(() => {
+              const cost = Date.now() - start
+              process_binding_time.add(cost)
+              this.contexts.delete(request.processId)
+            })
+        }
+        if (request.dbResult) {
+          const dbContext = this.contexts.get(request.processId)
+          try {
+            dbContext?.result(request.dbResult)
+          } catch (e) {
+            subject.error(new Error('db result error, process should stop'))
+          }
+        }
+      } catch (e) {
+        // should not happen
+        console.error('unexpect error during handle loop', e)
+      }
+    }
+  }
+
+  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, ChannelStoreContext> = new Map()
+
+  get(processId: number) {
+    return this.contexts.get(processId)
+  }
+
+  new(processId: number, subject: Subject<DeepPartial<ProcessStreamResponse>>) {
+    const context = new ChannelStoreContext(subject, processId)
+    this.contexts.set(processId, context)
+    return context
+  }
+
+  delete(processId: number) {
+    const context = this.get(processId)
+    context?.close()
+    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

@@ -0,0 +1,150 @@
+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, 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
+
+let unhandled: Error | undefined
+
+process
+  .on('uncaughtException', (err) => {
+    console.error('Uncaught Exception, please checking if await is properly used', err)
+    unhandled = err
+  })
+  .on('unhandledRejection', (reason, p) => {
+    // @ts-ignore ignore invalid ens error
+    if (reason?.message.startsWith('invalid ENS name (disallowed character: "*"')) {
+      return
+    }
+    console.error('Unhandled Rejection, please checking if await is properly', reason)
+    unhandled = reason as Error
+    // shutdownServers(1)
+  })
+
+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
+}
+
+const loader = async (options: any) => {
+  if (options.target) {
+    const m = await import(options.target)
+    console.debug('Module loaded, path:', options.target, 'module:', m)
+    return m
+  }
+}
+
+const configureChannel = new BroadcastChannel('configure_channel')
+configureChannel.onmessage = (request: ProcessConfigRequest) => {
+  getConfig(request)
+}
+
+async function start(request: StartRequest, options: any): Promise<Empty> {
+  if (started) {
+    return {}
+  }
+  freezeGlobalConfig()
+
+  try {
+    await loader(options)
+  } catch (e) {
+    throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))
+  }
+
+  await PluginManager.INSTANCE.start(request)
+  started = true
+  return {}
+}
+
+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, template instance:', startRequest.templateInstances?.length)
+    }
+
+    if (configRequest) {
+      await getConfig(configRequest)
+      console.debug('worker configured')
+    }
+  }
+
+  if (unhandled) {
+    const err = unhandled
+    unhandled = undefined
+    throw new RichServerError(
+      Status.UNAVAILABLE,
+      'Unhandled exception/rejection in previous request: ' + errorString(err),
+      [
+        DebugInfo.fromPartial({
+          detail: err.message,
+          stackEntries: err.stack?.split('\n')
+        })
+      ]
+    )
+  }
+
+  const result = await PluginManager.INSTANCE.processBinding(
+    request,
+    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>>
   ) {
@@ -474,7 +474,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   }
 }
 
-function recordRuntimeInfo(results: ProcessResult, handlerType: HandlerType) {
+export function recordRuntimeInfo(results: ProcessResult, handlerType: HandlerType) {
   for (const list of [results.gauges, results.counters, results.events, results.exports]) {
     list.forEach((e) => {
       e.runtimeInfo = {

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)
+  }
+}

package/src/tsup.config.ts

@@ -6,11 +6,12 @@ export default defineConfig({
       js: `import { createRequire as createRequireShim } from 'module'; const require = createRequireShim(import.meta.url);`
     }
   },
-  entry: ['src/index.ts', 'src/processor-runner.ts'],
+  entry: ['src/index.ts', 'src/processor-runner.ts', 'src/service-worker.ts', 'src/test-processor.test.ts'],
   outDir: 'lib',
   minify: process.env['BRANCH'] === 'release',
   sourcemap: true,
   clean: true,
   dts: true,
-  format: 'esm'
+  format: 'esm',
+  external: [/^piscina.*$/]
 })