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

package/server/engine/task/switch-scenario.ts

@@ -0,0 +1,67 @@
+import { getRepository } from '@things-factory/shell'
+import { access, deepClone } from '@things-factory/utils'
+
+import { Scenario } from '../../service/scenario/scenario'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SwitchScenario(step: InputStep, context: Context) {
+  var { logger, data, load } = context
+  var {
+    params: { accessor, cases, variables }
+  } = step
+
+  var value = access(accessor, data)
+
+  var scenarioName = cases[value] || cases['default']
+  logger.info(`switch to scenario '${scenarioName}' by value '${value}' .`)
+
+  var subscenario = await getRepository(Scenario).findOne({
+    where: {
+      name: scenarioName
+    },
+    relations: ['steps', 'domain']
+  })
+
+  logger.info(`Sub Scenario '${subscenario.name}' started.`)
+  var subContext = await load(step, subscenario, {
+    ...context,
+    data: {},
+    /* 
+      FIXME variables 설정이 안된 경우에 subscenario의 variables는 undefined가 되는 것이 맞겠지만, 
+      하위 호환성 유지를 위해서 부모의 variables를 사용함 
+    */
+    variables: variables ? deepClone(access(variables, data)) : context.variables
+  })
+  logger.info(`Sub Scenario '${subscenario.name}' done.`)
+
+  return {
+    data: subContext.data
+  }
+}
+
+SwitchScenario.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'map',
+    name: 'cases',
+    label: 'cases',
+    property: {
+      valuetype: 'scenario-input'
+    }
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'variables',
+    label: 'variables'
+  }
+]
+
+SwitchScenario.connectorFree = true
+
+TaskRegistry.registerTaskHandler('switch-scenario', SwitchScenario)

package/server/engine/task/switch-set.ts

@@ -0,0 +1,37 @@
+import { access } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SwitchSet(step: InputStep, { logger, data }: Context) {
+  var {
+    params: { accessor, cases }
+  } = step
+
+  var value = access(accessor, data)
+
+  var data = cases[value] || cases['default']
+
+  logger.info(`switch to data '${data}' by value '${value}' .`)
+
+  return {
+    data
+  }
+}
+
+SwitchSet.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'map',
+    name: 'cases',
+    label: 'cases'
+  }
+]
+
+SwitchSet.connectorFree = true
+
+TaskRegistry.registerTaskHandler('switch-set', SwitchSet)

package/server/engine/task/throw.ts

@@ -0,0 +1,27 @@
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function Throw(step: InputStep, { logger }: Context) {
+  var {
+    name,
+    params: { message }
+  } = step
+
+  throw `'${message}' is thrown by step '${name}'`
+
+  return {}
+}
+
+Throw.parameterSpec = [
+  {
+    type: 'string',
+    name: 'message',
+    label: 'message'
+  }
+]
+
+Throw.connectorFree = true
+Throw.help = 'integration/task/throw'
+
+TaskRegistry.registerTaskHandler('throw', Throw)

package/server/engine/task/utils/headless-pool-for-scenario.ts

@@ -0,0 +1,71 @@
+import * as genericPool from 'generic-pool'
+
+import { config, logger } from '@things-factory/env'
+
+try {
+  var puppeteer = require('puppeteer')
+} catch (err) {
+  logger.error(err)
+}
+
+var headlessPool
+
+export function getHeadlessPool() {
+  if (!headlessPool) {
+    headlessPool = genericPool.createPool(
+      {
+        create() {
+          console.log('headless instance in headless-pool-for-scensrio about to create')
+          return initializeChromium()
+        },
+        validate(browser) {
+          return Promise.race([
+            new Promise(res => setTimeout(() => res(false), 1500)),
+            browser
+              //@ts-ignore
+              .version()
+              .then(_ => true)
+              .catch(_ => false)
+          ])
+        },
+        destroy(browser) {
+          //@ts-ignore
+          return browser.close()
+        }
+      },
+      {
+        min: 2,
+        max: 10,
+        testOnBorrow: true,
+        acquireTimeoutMillis: 15000
+      }
+    )
+  }
+
+  return headlessPool
+}
+
+const CHROMIUM_PATH = config.get('CHROMIUM_PATH')
+
+async function initializeChromium() {
+  try {
+    if (!puppeteer) {
+      return
+    }
+
+    var launchSetting = {
+      args: ['--mute-audio', '--no-sandbox'],
+      headless: 'shell'
+    }
+
+    if (CHROMIUM_PATH) {
+      launchSetting['executablePath'] = CHROMIUM_PATH
+    }
+
+    const browser = await puppeteer.launch(launchSetting)
+
+    return browser
+  } catch (err) {
+    logger.error(err)
+  }
+}

package/server/engine/task/utils/substitute.ts

@@ -0,0 +1,44 @@
+const SELF = function (o) {
+  return o
+}
+
+function parse(text) {
+  var defaultIndex = text.indexOf('||')
+  var originText = ''
+  var defaultValue = ''
+  if (defaultIndex != -1) {
+    originText = text
+    defaultValue = text.substring(defaultIndex + 2, text.length - 1).trim()
+    text = text.replace(text.substring(defaultIndex, text.length - 1), '').trim()
+  }
+  var parsed = text
+    .substr(2, text.length - 3)
+    .trim()
+    .replace(/\[(\w+)\]/g, '.$1')
+    .replace(/^\./, '')
+    .split('.')
+    .filter(accessor => !!accessor.trim())
+  var accessors = parsed.slice(1)
+  return {
+    defaultValue: defaultValue,
+    match: text,
+    originText: originText || text,
+    target: parsed[0],
+    accessor:
+      accessors.length > 0
+        ? function (o) {
+            return accessors.reduce((o, accessor) => (o ? o[accessor] : undefined), o)
+          }
+        : SELF
+  }
+}
+
+export function substitute(value, data) {
+  var text = String(value)
+  var substituteVal = text.match(/#{[^}]*}/gi)
+  var prop = substituteVal ? parse(substituteVal[0]) : undefined
+  if (prop && data.hasOwnProperty(prop.target)) {
+    return prop.accessor(data[prop.target])
+  }
+  return value
+}

package/server/engine/task/variables.ts

@@ -0,0 +1,17 @@
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function Variables(step: InputStep, { variables }: Context) {
+  return {
+    data: variables instanceof Array ? [...variables] : typeof variables == 'object' ? { ...variables } : variables
+  }
+}
+
+Variables.parameterSpec = []
+
+Variables.connectorFree = true
+
+Variables.help = 'integration/task/variables'
+
+TaskRegistry.registerTaskHandler('variables', Variables)

package/server/engine/task-registry.ts

@@ -0,0 +1,23 @@
+import { TaskHandler } from './types'
+
+export class TaskRegistry {
+  static handlers: { [type: string]: TaskHandler } = {}
+
+  static getTaskHandler(type: string): TaskHandler {
+    return TaskRegistry.handlers[type]
+  }
+
+  static registerTaskHandler(type: string, handler: TaskHandler) {
+    TaskRegistry.handlers[type] = handler
+  }
+
+  static unregisterTaskHandler(type: string) {
+    delete TaskRegistry.handlers[type]
+  }
+
+  static getTaskHandlers(): { [propName: string]: TaskHandler } {
+    return {
+      ...TaskRegistry.handlers
+    }
+  }
+}

package/server/engine/types.ts

@@ -0,0 +1,114 @@
+import { Connection, PropertySpec, ScenarioInstance, ScenarioInstanceStatus, Step } from '../service'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+export interface Connector {
+  ready(connections: Connection[]): Promise<any>
+  connect(connection: Connection): Promise<any>
+  disconnect(connection: Connection): Promise<any>
+  parameterSpec: PropertySpec[]
+  taskPrefixes?: string[]
+  description?: string
+  help?: string
+}
+
+export type Context = {
+  /**
+   * Represents the domain context.
+   */
+  domain: Domain
+
+  /**
+   * User information.
+   */
+  user: User
+
+  /**
+   * Language code, for example 'en', 'ko'.
+   */
+  lng: string
+
+  /**
+   * Flag to indicate if the IP is unsafe, can be undefined.
+   */
+  unsafeIP: boolean | undefined
+
+  /**
+   * List of prohibited privileges, can be undefined.
+   */
+  prohibitedPrivileges: { category: string; privilege: string }[] | undefined
+
+  /**
+   * Logger for logging purposes.
+   */
+  logger: any
+
+  /**
+   * Function to publish events or messages.
+   */
+  publish: Function
+
+  /**
+   * Function to load resources or data.
+   */
+  load: Function
+
+  /**
+   * Current status of the scenario instance.
+   */
+  state: ScenarioInstanceStatus
+
+  /**
+   * General data storage object.
+   */
+  data: any
+
+  /**
+   * Variables related to the context.
+   */
+  variables: Object
+
+  /**
+   * Local GraphQL client object.
+   */
+  client: any /* graphql local client */
+
+  /**
+   * Root object, can be used for various purposes.
+   */
+  root?: ScenarioInstance
+
+  /**
+   * Array of function closures.
+   */
+  closures: Function[]
+
+  /**
+   * Function to check the state.
+   */
+  checkState: Function
+
+  /**
+   * MQTT subscriber context object.
+   */
+  __mqtt_subscriber?: any
+
+  /**
+   * socket listener context object.
+   */
+  __socket_listener?: any
+
+  /**
+   * csv readline context object.
+   */
+  __csv_resources?: any
+}
+
+export type TaskHandler = (
+  step: Step,
+  context: Context
+) => Promise<{
+  next?: string
+  state?: ScenarioInstanceStatus
+  data?: any
+}>

package/server/index.ts

@@ -0,0 +1,20 @@
+export * from './migrations'
+export * from './engine'
+export * from './controllers'
+export * from './service'
+
+import './routes'
+import './restful' /* APIs */
+
+import { ConnectionManager, ScenarioEngine } from './engine'
+
+process.on('bootstrap-module-start' as any, async ({ app, config, client }: any) => {
+  try {
+    await ConnectionManager.ready()
+    await ScenarioEngine.loadAll()
+
+    console.log('Scenario Engine has just started.')
+  } catch (ex) {
+    ConnectionManager.logger.error('Just has failed to start Scenario Engine.', ex)
+  }
+})

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/restful/index.ts

@@ -0,0 +1 @@
+import './unstable'

package/server/restful/unstable/index.ts

@@ -0,0 +1,7 @@
+import './scenario'
+import './scenarios'
+import './scenario-instance'
+import './scenario-instances'
+import './run-scenario'
+import './start-scenario'
+import './stop-scenario'

package/server/restful/unstable/run-scenario.ts

@@ -0,0 +1,51 @@
+import gql from 'graphql-tag'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+
+const debug = require('debug')('things-factory:integration-base:restful:unstable:run-scenario')
+
+router.post('/unstable/run-scenario/:scenarioName', async (context, next) => {
+  const { client } = context.state
+  const { scenarioName } = context.params
+  const body = context.request.body || {}
+  let { instanceName = '', variables = {} } = body
+
+  if (Object.keys(variables).length === 0) {
+    variables = body
+  }
+
+  debug('post:/unstable/run-scenario/:scenarioName', scenarioName)
+  let response = await client.mutate({
+    mutation: gql`
+      mutation ($instanceName: String, $scenarioName: String!, $variables: Object) {
+        runScenario(instanceName: $instanceName, scenarioName: $scenarioName, variables: $variables) {
+          instanceName
+          scenarioName
+          data
+          result
+          message
+          timestamp
+        }
+      }
+    `,
+    variables: {
+      instanceName,
+      scenarioName,
+      variables
+    },
+    context
+  })
+
+  const { errors, data } = response
+
+  if (!data) {
+    context.status = 500
+    context.body = errors
+
+    return
+  }
+
+  const { result } = data.runScenario
+
+  context.body = result
+})

package/server/restful/unstable/scenario-instance.ts

@@ -0,0 +1,52 @@
+import gql from 'graphql-tag'
+import { restfulApiRouter as router } from '@things-factory/api'
+
+const debug = require('debug')('things-factory:integration-base:restful:unstable:scenario-instance')
+
+router.get('/unstable/scenario-instance/:instanceName', async (context, next) => {
+  const { client } = context.state
+  const { instanceName } = context.params
+
+  debug('get:/unstable/scenario-instance/:instanceName', context.params)
+
+  context.body = await client.query({
+    query: gql`
+      query($instanceName: String!) {
+        scenarioInstance(instanceName: $instanceName) {
+          root {
+            instanceName
+            scenarioName
+            state
+            progress {
+              rounds
+              rate
+              steps
+              step
+            }
+            variables
+            data
+            message
+            timestamp
+          }
+          instanceName
+          scenarioName
+          state
+          progress {
+            rounds
+            rate
+            steps
+            step
+          }
+          variables
+          data
+          message
+          timestamp
+        }
+      }
+    `,
+    variables: {
+      instanceName
+    },
+    context
+  })
+})

package/server/restful/unstable/scenario-instances.ts

@@ -0,0 +1,80 @@
+import gql from 'graphql-tag'
+import { restfulApiRouter as router } from '@things-factory/api'
+
+const debug = require('debug')('things-factory:integration-base:restful:unstable:scenario-instances')
+
+function FPSparams(query) {
+  var { page, limit } = query
+
+  var filters = []
+  var sortings = []
+
+  page = parseInt(page)
+  limit = parseInt(limit)
+
+  var pagination = {
+    page: isNaN(page) ? 0 : page,
+    limit: isNaN(limit) ? 100 : limit
+  }
+
+  return {
+    filters,
+    sortings,
+    pagination
+  }
+}
+
+router.get('/unstable/scenario-instances', async (context, next) => {
+  const { client } = context.state
+
+  var { filters, sortings, pagination } = FPSparams(context.query)
+
+  debug('get:/unstable/scenario-instances', context.params)
+
+  context.body = await client.query({
+    query: gql`
+      query ($filters: [Filter!], $pagination: Pagination, $sortings: [Sorting!]) {
+        scenarioInstances(filters: $filters, pagination: $pagination, sortings: $sortings) {
+          items {
+            root {
+              instanceName
+              scenarioName
+              state
+              progress {
+                rounds
+                rate
+                steps
+                step
+              }
+              variables
+              data
+              message
+              timestamp
+            }
+            instanceName
+            scenarioName
+            state
+            progress {
+              rounds
+              rate
+              steps
+              step
+            }
+            variables
+            data
+            message
+            timestamp
+          }
+
+          total
+        }
+      }
+    `,
+    variables: {
+      filters,
+      pagination,
+      sortings
+    },
+    context
+  })
+})

package/server/restful/unstable/scenario.ts

@@ -0,0 +1,41 @@
+import gql from 'graphql-tag'
+import { restfulApiRouter as router } from '@things-factory/api'
+
+const debug = require('debug')('things-factory:integration-base:restful:unstable:scenario')
+
+router.get('/unstable/scenario/:id', async (context, next) => {
+  const { client } = context.state
+  const { id } = context.params
+
+  debug('get:/unstable/scenario/:id', context.params)
+
+  context.body = await client.query({
+    query: gql`
+      query ($id: String!) {
+        scenario(id: $id) {
+          id
+          name
+          description
+          state
+          schedule
+          timezone
+          steps {
+            id
+            name
+            description
+            sequence
+            task
+            skip
+            log
+            connection
+            params
+          }
+        }
+      }
+    `,
+    variables: {
+      id
+    },
+    context
+  })
+})