@things-factory/integration-base 8.0.0 → 9.0.0-beta.3

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

@@ -1,563 +0,0 @@
-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

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

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

@@ -1,55 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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 = []