@things-factory/integration-base 8.0.0-beta.8 → 8.0.0

package/server/service/scenario-instance/scenario-instance-type.ts

@@ -0,0 +1,563 @@
+import 'winston-daily-rotate-file'
+
+import orderBy from 'lodash/orderBy'
+import moment from 'moment-timezone'
+import { Field, Int, ObjectType, registerEnumType } from 'type-graphql'
+import util from 'util'
+import { createLogger, format, transports } from 'winston'
+
+import { Domain, pubsub, PubSubLogTransport, ScalarObject } from '@things-factory/shell'
+import { cacheService } from '@things-factory/cache-service'
+import { User } from '@things-factory/auth-base'
+import { sleep } from '@things-factory/utils'
+
+import { publishData } from '../../controllers/publish-data'
+import { ConnectionManager } from '../../engine/connection-manager'
+import { TaskRegistry } from '../../engine'
+import { Context } from '../../engine/types'
+import { Step } from '../step/step-type'
+import { handler as edgeHandler } from '../../engine/edge-client'
+
+const debug = require('debug')('things-factory:integration-base:scenario-instance')
+const { combine, errors, splat, printf } = format
+
+const LOGFORMAT = printf(({ level, message, timestamp, stack }) => {
+  return `${timestamp} ${level}: ${stack || message}`
+})
+
+function getSystemTimeZone() {
+  try {
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone
+    if (!timeZone) {
+      throw new Error('Unable to resolve timeZone')
+    }
+    return timeZone
+  } catch (e) {
+    console.warn('Failed to get system timeZone, falling back to UTC.', e)
+    return 'UTC'
+  }
+}
+
+const SYSTEM_TZ = getSystemTimeZone()
+const systemTimestamp = format((info, opts: { tz?: string }) => {
+  if (opts.tz) info.timestamp = moment().tz(opts.tz).format()
+  return info
+})
+
+export enum ScenarioInstanceStatus {
+  READY = 'READY',
+  STARTED = 'STARTED',
+  STOPPED = 'STOPPED',
+  HALTED = 'HALTED',
+  UNLOADED = 'UNLOADED'
+}
+
+registerEnumType(ScenarioInstanceStatus, {
+  name: 'ScenarioInstanceStatus',
+  description: 'state enumeration of a scenario-instance'
+})
+
+@ObjectType()
+export class ScenarioInstanceProgress {
+  @Field(type => Int)
+  rounds: number
+
+  @Field(type => Int)
+  rate: number
+
+  @Field(type => Int)
+  steps: number
+
+  @Field(type => Int)
+  step: number
+}
+
+@ObjectType()
+export class ScenarioInstanceState {
+  @Field({ nullable: true })
+  public domain: Domain
+
+  @Field({ nullable: true })
+  public instanceName: string
+
+  @Field({ nullable: true })
+  public scenarioName: string
+
+  @Field(type => ScenarioInstanceStatus, { nullable: true })
+  public state: ScenarioInstanceStatus
+
+  @Field(type => ScalarObject, { nullable: true })
+  public variables: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  public data: any
+
+  @Field(type => ScenarioInstanceProgress, { nullable: true })
+  public progress: ScenarioInstanceProgress
+
+  @Field({ nullable: true })
+  public message: string
+
+  @Field({ nullable: true })
+  public timestamp: Date
+}
+
+@ObjectType()
+export class ScenarioInstanceRunResult {
+  @Field({ nullable: true })
+  public scenarioName: string
+
+  @Field({ nullable: true })
+  public instanceName: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  public variables: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  public data: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  public result: any
+
+  @Field({ nullable: true })
+  public timestamp: Date
+
+  @Field({ nullable: true })
+  public message: string
+
+  @Field({ nullable: true })
+  public state: ScenarioInstanceStatus
+}
+
+@ObjectType()
+export class ScenarioInstance {
+  private subScenarioInstances: ScenarioInstance[] = [] // TODO Imple by WeakSet
+
+  public context: Context
+
+  @Field({ nullable: true })
+  public domain: Domain
+
+  @Field({ nullable: true })
+  public user: User
+
+  @Field({ nullable: true })
+  public scenarioName: string
+
+  @Field({ nullable: true })
+  public instanceName: string
+
+  @Field({ nullable: true })
+  get root(): ScenarioInstance {
+    return this.context?.root
+  }
+
+  @Field({ nullable: true })
+  get state(): ScenarioInstanceStatus {
+    return this.context?.state
+  }
+
+  @Field(type => ScenarioInstanceProgress, { nullable: true })
+  get progress(): ScenarioInstanceProgress {
+    return this.calcProgress()
+  }
+
+  @Field(type => ScalarObject, { nullable: true })
+  get variables(): any {
+    return this.context?.variables
+  }
+
+  @Field(type => ScalarObject, { nullable: true })
+  get data(): any {
+    return this.context?.data
+  }
+
+  @Field(type => ScalarObject, { nullable: true })
+  result: any
+
+  @Field({ nullable: true })
+  get timestamp(): Date {
+    return new Date()
+  }
+
+  @Field({ nullable: true })
+  public message: string
+
+  private scenarioId: string
+  private scenarioTtl: number
+  private steps: Step[]
+  private rounds: number = 0
+
+  private lastStep: number = -1
+  private nextStep: number = -1
+  private disposer: any
+  public addSubScenarioInstance(instance: ScenarioInstance): ScenarioInstance[] {
+    this.subScenarioInstances.push(instance)
+    return this.subScenarioInstances
+  }
+
+  public getSubScenarioInstances(): ScenarioInstance[] {
+    return this.subScenarioInstances
+  }
+
+  public async stopSubScenarios() {
+    var subScenarioInstances = this.getSubScenarioInstances()
+
+    var subInstance = subScenarioInstances.pop()
+    while (subInstance) {
+      await subInstance.dispose()
+      subInstance = subScenarioInstances.pop()
+    }
+  }
+
+  constructor(
+    instanceName,
+    {
+      id: scenarioId,
+      ttl: scenarioTtl,
+      name: scenarioName,
+      steps,
+      domain: scenarioDomain
+    }: { id: string; ttl?: number; name: string; steps: Step[]; domain: Domain },
+    context?
+  ) {
+    var { domain, user, lng, unsafeIP, prohibitedPrivileges } = context || {}
+    domain ||= scenarioDomain
+
+    this.scenarioId = scenarioId
+    this.scenarioTtl = scenarioTtl
+    this.instanceName = instanceName
+    this.scenarioName = scenarioName
+    this.steps = orderBy(steps || [], step => step.sequence)
+    this.domain = domain
+    this.user = user
+    this.disposer = context?.disposer
+
+    this.context = {
+      domain,
+      user,
+      lng,
+      unsafeIP,
+      prohibitedPrivileges,
+      logger:
+        context?.logger ||
+        createLogger({
+          format: combine(errors({ stack: true }), systemTimestamp({ tz: SYSTEM_TZ }), splat(), LOGFORMAT),
+          transports: [
+            new (transports as any).DailyRotateFile({
+              filename: `logs/${domain.subdomain}/scenario-${scenarioName}-%DATE%.log`,
+              datePattern: 'YYYY-MM-DD-HH',
+              zippedArchive: false,
+              maxSize: '5m',
+              maxFiles: '14d',
+              level: 'info'
+            }),
+            new PubSubLogTransport({
+              topic: 'scenario-instance-log',
+              source: { domain, scenarioName, instanceName }
+            })
+          ]
+        }),
+      publish: context?.publish || this.publishData.bind(this),
+      load: context?.load || this.loadSubscenario.bind(this),
+      data: context?.data || {},
+      variables: context?.variables || {},
+      client: context?.client,
+      state: ScenarioInstanceStatus.STOPPED,
+      root: context?.root || this,
+      closures: [],
+      checkState(state = ScenarioInstanceStatus.STARTED) {
+        return this.state == state
+      }
+    }
+
+    this.setState(ScenarioInstanceStatus.READY)
+  }
+
+  async run() {
+    var state = this.getState()
+    if (state == ScenarioInstanceStatus.STARTED || this.steps.length == 0) {
+      return
+    }
+
+    this.setState(ScenarioInstanceStatus.STARTED)
+    var context = this.context
+
+    try {
+      while (this.getState() == ScenarioInstanceStatus.STARTED) {
+        if (this.nextStep == -1) {
+          this.setNextStep(0)
+        }
+
+        if (this.nextStep == 0) {
+          this.rounds++
+          this.context.logger.info(`Start ${this.rounds} Rounds  #######`)
+        }
+
+        var step = this.steps[this.nextStep]
+        var next, data
+
+        if (!step.skip) {
+          // @ts-ignore: Initializer provides no value for this binding element and the binding element has no default value.
+          var { next, state: stepState, data } = (await this.process(step, context)) || {}
+          context.data[step.name] = data
+        } else {
+          next = ''
+          stepState = undefined
+        }
+
+        this.publishState()
+
+        await sleep(1)
+
+        if (next) {
+          this.setNextStep(
+            this.steps.findIndex(step => {
+              return step.name == next
+            })
+          )
+          if (this.nextStep == -1) {
+            throw 'Not Found Next Step'
+          }
+        } else if (this.nextStep == this.steps.length - 1) {
+          this.setState(ScenarioInstanceStatus.STOPPED)
+        } else {
+          this.setNextStep(this.nextStep + 1)
+        }
+
+        /* last step 에 의해서 시나리오 state를 변경할 수 있도록 함. */
+        if (stepState !== undefined) {
+          this.setState(stepState)
+        }
+      }
+    } catch (ex) {
+      const message = ex.stack ? ex.stack : ex
+      const { scenarioName, domain } = this
+
+      this.context.logger.error(ex)
+
+      debug('failed to run ', `[ Domain: ${domain.name}, Scenario: ${scenarioName} ]\n`, ex)
+      this.setState(
+        ScenarioInstanceStatus.HALTED,
+        typeof message == 'object' ? JSON.stringify(message, null, 2) : message
+      )
+
+      throw ex
+    }
+
+    this.result = this.steps
+      .filter(step => !!step.result)
+      .reduce((sum, step) => {
+        sum[step.name] = this.context.data[step.name]
+        return sum
+      }, {})
+
+    const { scenarioId, scenarioTtl, variables, message, scenarioName, instanceName, result, domain } = this
+    const obj = {
+      scenarioName,
+      instanceName,
+      variables,
+      data: this.data,
+      result,
+      timestamp: new Date(),
+      message,
+      state: ScenarioInstanceStatus.STOPPED /* redundent, no meaning */
+    }
+
+    if (this.scenarioTtl && this.scenarioId) {
+      setTimeout(() => {
+        cacheService.setInCache(scenarioId, { domain: domain.id, variables: variables || {} }, obj, scenarioTtl)
+      })
+    }
+
+    return obj
+  }
+
+  async loadSubscenario(step, scenarioConfig, context) {
+    var { name: stepName, params } = step
+    var { preventErrorPropagation } = params || {}
+
+    debug('load-subscenario', this.instanceName, stepName, scenarioConfig.name)
+
+    context.data[stepName] = {}
+
+    let subContext = {
+      ...context,
+      data: context.data[stepName],
+      closures: [],
+      state: ScenarioInstanceStatus.READY
+    }
+
+    if (!scenarioConfig.domain) {
+      scenarioConfig.domain = context.domain
+    }
+
+    var subScenarioInstance = new ScenarioInstance(`${this.instanceName}$${stepName}`, scenarioConfig, subContext)
+    this.addSubScenarioInstance(subScenarioInstance)
+    await subScenarioInstance.run()
+
+    if (!preventErrorPropagation && subScenarioInstance.getState() == ScenarioInstanceStatus.HALTED) {
+      throw new Error(`Sub-scenario[${this.instanceName}$${stepName}] is halted.`)
+    }
+
+    return subContext
+  }
+
+  publishData(tag, data) {
+    publishData(tag, data, this.context)
+  }
+
+  publishState() {
+    const {
+      instanceName,
+      scenarioName,
+      steps,
+      domain,
+      message,
+      context: { data, variables, state }
+    } = this
+
+    pubsub.publish('scenario-instance-state', {
+      scenarioInstanceState: {
+        domain,
+        instanceName,
+        scenarioName,
+        state,
+        variables,
+        progress: this.calcProgress(),
+        data,
+        message,
+        timestamp: new Date()
+      }
+    })
+
+    this.context.logger.info(this.message)
+  }
+
+  calcProgress(): ScenarioInstanceProgress {
+    var steps = this.steps.length
+    var step = Math.max(this.lastStep, 0)
+
+    return {
+      rounds: this.rounds,
+      rate: steps ? Math.round(100 * (step / steps)) : 0,
+      steps,
+      step
+    }
+  }
+
+  setNextStep(step) {
+    this.lastStep = this.nextStep + 1
+    this.nextStep = step
+  }
+
+  getState(): ScenarioInstanceStatus {
+    return this.context.state
+  }
+
+  setState(state, message?) {
+    if (this.context.state == state) {
+      return
+    }
+
+    this.message = `${this.instanceName}:[state changed] ${ScenarioInstanceStatus[this.getState()]} => ${ScenarioInstanceStatus[state]}${
+      message ? ' caused by ' + util.inspect(message, false, 2, true) : ''
+    }`
+
+    this.context.state = state
+
+    if (state == ScenarioInstanceStatus.STOPPED || state == ScenarioInstanceStatus.HALTED) {
+      this.setNextStep(-1)
+      this.setState(ScenarioInstanceStatus.UNLOADED)
+    } else if (state == ScenarioInstanceStatus.UNLOADED) {
+      this.setNextStep(-1)
+      this.dispose()
+    }
+
+    this.publishState()
+  }
+
+  async start() {
+    await this.run()
+  }
+
+  stop() {
+    if (this.getState() !== ScenarioInstanceStatus.HALTED) {
+      this.setState(ScenarioInstanceStatus.STOPPED)
+    }
+  }
+
+  unload() {
+    this.setState(ScenarioInstanceStatus.UNLOADED)
+  }
+
+  async dispose() {
+    await this.stopSubScenarios()
+
+    this.unload()
+
+    var closure = this.context?.closures?.pop()
+    while (closure) {
+      closure.call(this)
+      closure = this.context?.closures?.pop()
+    }
+
+    if (this.disposer) {
+      await this.disposer.call(this)
+    }
+
+    // {{ CHECKPOINT 본 인스턴스를 위해서 생성된 logger를 닫는다. 사용을 완료하고 닫기위해서 지연해서 수행한다.
+    if (this.context?.logger) {
+      setTimeout(() => {
+        this.context.logger.close()
+      }, 300)
+    }
+    // }}
+  }
+
+  async process(step, context): Promise<{ next: string; state: ScenarioInstanceStatus; data: object }> {
+    this.context.logger.info(`Step '${step.name}'(${step.id}) started.`)
+
+    step = {
+      ...step
+    } // copy step
+
+    try {
+      step.params = JSON.parse(step.params)
+    } catch (ex) {
+      this.context.logger.error(`params(${step.params}) parsing error. params must be a JSON.`, ex)
+    }
+    step.params = step.params || {}
+
+    const connection =
+      step.connection && ConnectionManager.getConnectionInstanceEntityByName(this.domain, step.connection)
+
+    if (!connection || !connection.edgeId) {
+      var handler = TaskRegistry.getTaskHandler(step.task)
+      if (!handler) {
+        throw new Error(`no task handler for step '${step.name}'(${step.id})`)
+      }
+
+      var retval: any = await handler(step, context)
+    } else {
+      var retval: any = await edgeHandler(step, context)
+    }
+
+    if (step.log) {
+      var { data } = retval || {}
+      this.context.logger.info(`returns ${typeof data == 'string' ? data : JSON.stringify(data, null, 2)}`)
+    }
+
+    this.context.logger.info(`Step done.`)
+    return retval
+  }
+}
+
+@ObjectType()
+export class ScenarioInstanceList {
+  @Field(type => [ScenarioInstance])
+  items: ScenarioInstance[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/scenario-queue/index.ts

@@ -0,0 +1,4 @@
+import { ScenarioQueueSubscription } from './scenario-queue-subscription'
+
+export const entities = []
+export const resolvers = [ScenarioQueueSubscription]

package/server/service/scenario-queue/scenario-queue-subscription.ts

@@ -0,0 +1,55 @@
+import { Resolver, Subscription, Root, Arg } from 'type-graphql'
+import { ScenarioQueueState } from './scenario-queue-type'
+import { pubsub } from '@things-factory/shell'
+import { filter, pipe } from 'graphql-yoga'
+import { ScenarioEngine } from '../../engine'
+
+const debug = require('debug')('things-factory:integration:connection-subscription')
+
+@Resolver()
+export class ScenarioQueueSubscription {
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const subdomain = domain?.subdomain
+
+      debug('subscribe', subdomain)
+
+      if (!domain) {
+        throw new Error('domain required.')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      process.nextTick(async () => {
+        var queue = ScenarioEngine.getPendingQueue(domain)
+        if (queue) {
+          pubsub.publish('scenario-queue-state', {
+            scenarioQueueState: {
+              domain,
+              queue: queue.queue
+            }
+          })
+        }
+      })
+
+      return pipe(
+        pubsub.subscribe('scenario-queue-state'),
+        filter((payload: { scenarioQueueState: ScenarioQueueState }) => {
+          const { domain: pdomain } = payload.scenarioQueueState
+
+          if (pdomain?.subdomain !== subdomain) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  scenarioQueueState(@Root() payload: { scenarioQueueState: ScenarioQueueState }): ScenarioQueueState {
+    return payload.scenarioQueueState
+  }
+}

package/server/service/scenario-queue/scenario-queue-type.ts

@@ -0,0 +1,27 @@
+import { Field, Int, ObjectType } from 'type-graphql'
+
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+@ObjectType()
+export class PendingObject {
+  @Field(type => ScalarObject)
+  stuff: any
+
+  @Field()
+  due: string
+
+  @Field(type => Int)
+  priority: number
+
+  @Field({ nullable: true })
+  tag: String
+}
+
+@ObjectType()
+export class ScenarioQueueState {
+  @Field()
+  domain: Domain
+
+  @Field(type => [PendingObject])
+  queue: PendingObject[]
+}

package/server/service/state-register/data-resolver.ts

@@ -0,0 +1,56 @@
+import { filter, pipe } from 'graphql-yoga'
+import { Arg, Resolver, Root, Subscription } from 'type-graphql'
+
+import { pubsub, Data, getRepository } from '@things-factory/shell'
+import { StateRegister } from './state-register'
+
+/* 이 Resolver는 @things-factory/shell에서 등록한 DataResolver를 Overide 한 것이다. */
+@Resolver()
+export class DataResolver {
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const { tag } = args
+      const subdomain = domain?.subdomain
+
+      if (!domain || !tag) {
+        throw new Error('domain and tag required')
+      }
+
+      //@ts-ignore
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      process.nextTick(async () => {
+        /* state-register에 등록된 태그라면, 현재 상태값을 publish 한다. */
+        const { domain } = context.state
+
+        const state = await getRepository(StateRegister).findOne({
+          where: { domain: { id: domain.id }, name: tag }
+        })
+
+        if (state) {
+          pubsub.publish('data', {
+            data: {
+              domain,
+              tag,
+              data: state.state
+            }
+          })
+        }
+      })
+
+      return pipe(
+        pubsub.subscribe('data'),
+        filter((payload: { data: Data }) => {
+          const { domain: pdomain, tag: ptag, data } = payload.data
+          return tag === ptag && subdomain === pdomain?.subdomain
+        })
+      )
+    }
+  })
+  data(@Root() payload: { data: Data }, @Arg('tag') tag: string): Data {
+    return payload.data
+  }
+}

package/server/service/state-register/index.ts

@@ -0,0 +1,8 @@
+import { StateRegister } from './state-register'
+import { StateRegisterQuery } from './state-register-query'
+import { StateRegisterMutation } from './state-register-mutation'
+import { DataResolver } from './data-resolver'
+
+export const entities = [StateRegister]
+export const resolvers = [StateRegisterQuery, StateRegisterMutation, DataResolver]
+export const subscribers = []