@things-factory/integration-base 8.0.0-beta.1 → 8.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.2",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -27,14 +27,14 @@
   "dependencies": {
     "@apollo/client": "^3.6.9",
     "@operato/moment-timezone-es": "^8.0.0-beta",
-    "@things-factory/api": "^8.0.0-beta.1",
-    "@things-factory/auth-base": "^8.0.0-beta.1",
-    "@things-factory/cache-service": "^8.0.0-beta.1",
-    "@things-factory/env": "^8.0.0-beta.1",
-    "@things-factory/oauth2-client": "^8.0.0-beta.1",
-    "@things-factory/scheduler-client": "^8.0.0-beta.1",
-    "@things-factory/shell": "^8.0.0-beta.1",
-    "@things-factory/utils": "^8.0.0-beta.1",
+    "@things-factory/api": "^8.0.0-beta.2",
+    "@things-factory/auth-base": "^8.0.0-beta.2",
+    "@things-factory/cache-service": "^8.0.0-beta.2",
+    "@things-factory/env": "^8.0.0-beta.2",
+    "@things-factory/oauth2-client": "^8.0.0-beta.2",
+    "@things-factory/scheduler-client": "^8.0.0-beta.2",
+    "@things-factory/shell": "^8.0.0-beta.2",
+    "@things-factory/utils": "^8.0.0-beta.2",
     "async-mqtt": "^2.5.0",
     "chance": "^1.1.11",
     "cross-fetch": "^3.0.4",
@@ -45,5 +45,5 @@
     "readline": "^1.3.0",
     "ses": "^1.5.0"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/controllers/index.ts

@@ -1,2 +0,0 @@
-export * from './scenario-controller'
-export * from './publish-data'

package/server/controllers/publish-data.ts

@@ -1,29 +0,0 @@
-import { Domain, getRepository, pubsub } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-import { StateRegister } from '../service/state-register/state-register'
-
-export async function publishData(tag: string, data: any, { domain, user }: { domain: Domain; user: User }) {
-  const repository = getRepository(StateRegister)
-
-  const stateRegister = await repository.findOne({
-    where: { domain: { id: domain?.id }, name: tag }
-  })
-
-  if (stateRegister) {
-    await repository.save({
-      ...stateRegister,
-      state: data,
-      writer: user,
-      wroteAt: new Date()
-    })
-  }
-
-  pubsub.publish('data', {
-    data: {
-      domain,
-      tag,
-      data
-    }
-  })
-}

package/server/controllers/scenario-controller.ts

@@ -1,156 +0,0 @@
-import { getRepository, Domain, GraphqlLocalClient } from '@things-factory/shell'
-import { checkUserHasRole } from '@things-factory/auth-base'
-import { cacheService } from '@things-factory/cache-service'
-
-import { ScenarioEngine } from '../engine/scenario-engine'
-import { Scenario } from '../service/scenario/scenario'
-import { ScenarioInstance, ScenarioInstanceRunResult } from '../service/scenario-instance/scenario-instance-type'
-import { Step } from '../service/step/step-type'
-
-const debug = require('debug')('things-factory:integration-base:controller:run-scenario')
-
-async function findScenario(
-  scenarioName: string,
-  domain: Domain
-): Promise<{
-  id: string
-  ttl: number
-  name: string
-  steps: Step[]
-  domain: Domain
-}> {
-  var repository = getRepository(Scenario)
-
-  var scenario = await repository.findOne({
-    where: { domain: { id: domain.id }, name: scenarioName },
-    relations: ['domain', 'steps', 'role', 'creator', 'updater']
-  })
-
-  if (!scenario && domain.parentId) {
-    scenario = await repository.findOne({
-      where: { domain: { id: domain.parentId }, name: scenarioName },
-      relations: ['domain', 'steps', 'role', 'creator', 'updater']
-    })
-  }
-
-  return scenario as any
-}
-
-export async function checkHasRole(scenario: Partial<Scenario>, context: ResolverContext): Promise<void> {
-  const { domain, user } = context.state
-  if (!(await checkUserHasRole(scenario.roleId, domain, user))) {
-    throw new Error(
-      context.t('error.scenario run unauthorized', {
-        scenario: scenario.name
-      })
-    )
-  }
-}
-
-export async function runScenario(
-  instanceName: string,
-  scenarioName: string,
-  variables: any,
-  context: ResolverContext
-): Promise<ScenarioInstanceRunResult> {
-  const { domain, user, lng } = context.state
-
-  debug('runScenario', scenarioName, instanceName, variables)
-
-  var scenario = await findScenario(scenarioName, domain)
-
-  if (!scenario) {
-    throw new Error(
-      context.t('error.scenario not found', {
-        scenario: scenarioName
-      })
-    )
-  }
-
-  await checkHasRole(scenario, context)
-
-  if (scenario.ttl > 0) {
-    const cachedValue = await cacheService.getFromCache(scenario.id, { domain: domain.id, variables: variables || {} })
-    if (cachedValue) {
-      return cachedValue.value
-    }
-  }
-
-  /* 시나리오 인스턴스를 생성한다. */
-  instanceName = instanceName || scenarioName + '-' + String(Date.now())
-  var instance = new ScenarioInstance(instanceName, scenario, {
-    domain,
-    user,
-    lng,
-    variables,
-    client: GraphqlLocalClient.client
-  })
-
-  try {
-    return await instance.run()
-  } catch (err) {
-    console.error(err)
-
-    throw new Error(
-      context.t('error.scenario run error', {
-        scenario: scenarioName
-      })
-    )
-  }
-}
-
-export async function startScenario(
-  instanceName: string,
-  scenarioName: string,
-  variables: any,
-  context: ResolverContext
-): Promise<ScenarioInstance> {
-  const { domain, user, lng } = context.state
-
-  debug('startScenario', instanceName, scenarioName, variables)
-
-  var scenario = await findScenario(scenarioName, domain)
-
-  if (!scenario) {
-    throw new Error(
-      context.t('error.scenario not found', {
-        scenario: scenarioName
-      })
-    )
-  }
-
-  await checkHasRole(scenario, context)
-
-  instanceName = instanceName || scenarioName
-  return await ScenarioEngine.load(instanceName, scenario, { domain, user, lng, variables })
-}
-
-export async function stopScenario(
-  instanceName: string,
-  context: ResolverContext
-): Promise<ScenarioInstance | undefined> {
-  const { domain, user, unsafeIP, prohibitedPrivileges } = context.state
-
-  debug('stopScenario', instanceName)
-
-  runScenario
-
-  var scenarioInstance = ScenarioEngine.getScenarioInstance(domain, instanceName)
-
-  if (!scenarioInstance) {
-    debug('stopScenario', `ScenarioInstance(${instanceName}) Not Found.`)
-    throw new Error(
-      context.t('error.scenario instance not found', {
-        instance: instanceName
-      })
-    )
-  }
-
-  var scenario = await findScenario(scenarioInstance.scenarioName, domain)
-
-  await checkHasRole(scenario, context)
-
-  await ScenarioEngine.unload(domain, instanceName)
-
-  return scenarioInstance
-}

package/server/engine/analyzer/analyze-integration.ts

@@ -1,115 +0,0 @@
-import uniq from 'lodash/uniq'
-
-import { Domain, getRepository } from '@things-factory/shell'
-import { Scenario } from '../../service/scenario/scenario'
-import { Connection } from '../../service/connection/connection-type'
-
-export async function analyzeIntegration(domain: Domain) {
-  const tagNames = []
-
-  const model = {
-    nodes: [],
-    relationships: []
-  }
-
-  var id = 0
-
-  const scenarios = await getRepository(Scenario).find({
-    where: { domain: { id: domain.id } },
-    relations: ['steps']
-  })
-
-  const connections = await getRepository(Connection).find({
-    where: { domain: { id: domain.id } }
-  })
-
-  model.nodes = model.nodes.concat(
-    scenarios.map(scenario => {
-      return {
-        id: scenario.id,
-        labels: ['Scenario'],
-        text: scenario.name,
-        icon: 'settings',
-        properties: {
-          name: scenario.name,
-          description: scenario.description
-        }
-      }
-    })
-  )
-
-  model.nodes = model.nodes.concat(
-    connections.map(connection => {
-      return {
-        id: connection.id,
-        labels: ['Connection'],
-        text: connection.name,
-        icon: 'link',
-        properties: {
-          name: connection.name,
-          description: connection.description
-        }
-      }
-    })
-  )
-
-  scenarios.forEach(scenario => {
-    const connectionNames = uniq(scenario.steps.map(step => step.connection).filter(Boolean))
-    const connectionList = connectionNames
-      .map(connectionName => connections.find(connection => connection.name == connectionName))
-      .filter(Boolean)
-
-    const relationships = connectionList.map(connection => {
-      return {
-        id: ++id,
-        type: 'using',
-        startNode: scenario.id,
-        endNode: connection.id,
-        properties: {}
-      }
-    })
-
-    model.relationships = model.relationships.concat(relationships)
-  })
-
-  scenarios.forEach(scenario => {
-    const tags = uniq(
-      scenario.steps
-        .filter(step => !step.connection && step.task == 'publish')
-        .map(step => JSON.parse(step.params)?.tag)
-        .filter(Boolean)
-    )
-
-    for (const tag of tags) {
-      if (tagNames.includes(tag)) {
-        continue
-      }
-
-      model.nodes.push({
-        id: `tag-${tag}`,
-        labels: ['Tag'],
-        text: tag,
-        icon: 'label',
-        properties: {
-          tag
-        }
-      })
-
-      tagNames.push(tag)
-    }
-
-    const relationships = tags.map(tag => {
-      return {
-        id: ++id,
-        type: 'publish',
-        startNode: scenario.id,
-        endNode: `tag-${tag}`,
-        properties: {}
-      }
-    })
-
-    model.relationships = model.relationships.concat(relationships)
-  })
-
-  return model
-}

package/server/engine/connection-manager.ts

@@ -1,239 +0,0 @@
-import moment from 'moment-timezone'
-import { createLogger, format, transports } from 'winston'
-
-import { Domain, getRepository, pubsub, PubSubLogTransport } from '@things-factory/shell'
-
-import { Connection, ConnectionStatus } from '../service'
-import { Connector } from './types'
-import { ProxyConnector } from './connector/proxy-connector'
-
-const { combine, splat, printf, errors } = format
-const debug = require('debug')('things-factory:integration-base:connections')
-
-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 class ConnectionManager {
-  private static connectors: { [propName: string]: Connector } = {}
-  private static connections: { [domainId: string]: { [name: string]: any } } = {}
-  private static entities = {}
-  private static logFormat = printf(({ level, message, timestamp, stack }) => {
-    return `${timestamp} ${level}: ${stack || message}`
-  })
-
-  public static logger = createLogger({
-    format: combine(errors({ stack: true }), systemTimestamp({ tz: SYSTEM_TZ }), splat(), ConnectionManager.logFormat),
-    transports: [
-      new (transports as any).DailyRotateFile({
-        filename: `logs/connections-%DATE%.log`,
-        datePattern: 'YYYY-MM-DD-HH',
-        zippedArchive: false,
-        maxSize: '20m',
-        maxFiles: '14d',
-        level: 'info'
-      }),
-      new PubSubLogTransport({
-        topic: 'connection-log'
-      })
-    ]
-  })
-
-  static async ready() {
-    const CONNECTIONS = (
-      await getRepository(Connection).find({
-        where: { active: true },
-        relations: ['domain', 'edge', 'creator', 'updater']
-      })
-    ).map(connection => {
-      var params = {}
-      try {
-        params = JSON.parse(connection.params || '{}')
-      } catch (ex) {
-        ConnectionManager.logger.error(`connection '${connection.name}' params should be JSON format`, ex)
-      }
-
-      return {
-        ...connection,
-        params
-      }
-    })
-
-    ConnectionManager.logger.info('Initializing ConnectionManager...')
-
-    return await Promise.all(
-      [...Object.keys(ConnectionManager.connectors), 'proxy-connector'].map(type => {
-        const connector = type == 'proxy-connector' ? ProxyConnector.instance : ConnectionManager.getConnector(type)
-
-        ConnectionManager.logger.info(`Connector '${type}' started to ready`)
-
-        return connector
-          .ready(
-            CONNECTIONS.filter(connection => {
-              if (type == 'proxy-connector') {
-                return !!connection.edge
-              } else {
-                return !connection.edge && connection.type == type
-              }
-            }) as any
-          )
-          .catch(error => {
-            ConnectionManager.logger.error(error)
-          })
-          .then(() => {
-            ConnectionManager.logger.info(`All connector for '${type}' ready`)
-          })
-      })
-    ).then(() => {
-      ConnectionManager.logger.info('ConnectionManager initialization done:')
-      Object.keys(ConnectionManager.connections).forEach(key => {
-        var connections = ConnectionManager.connections[key]
-        ConnectionManager.logger.info('For domain(%s) : %s', key, JSON.stringify(Object.keys(connections)))
-      })
-    })
-  }
-
-  static registerConnector(type: string, connector: Connector) {
-    ConnectionManager.connectors[type] = connector
-  }
-
-  static getConnector(type: string): Connector {
-    return ConnectionManager.connectors[type]
-  }
-
-  static getConnectors(): { [connectorName: string]: Connector } {
-    return {
-      ...ConnectionManager.connectors
-    }
-  }
-
-  static unregisterConnector(type: string) {
-    delete ConnectionManager.connectors[type]
-  }
-
-  static getConnections() {
-    return ConnectionManager.connections
-  }
-
-  static getEntities() {
-    return ConnectionManager.entities
-  }
-
-  static getConnectionInstance(connection: Connection): any {
-    const { domain, name } = connection
-    return ConnectionManager.connections[domain.id]?.[name]
-  }
-
-  static getConnectionInstanceByName(domain: Domain, name: string) {
-    const connections = ConnectionManager.connections[domain.id]
-    const connection = connections?.[name]
-
-    if (!connection) {
-      throw `The connection with the given name(${name}) cannot be found`
-    }
-
-    return connection
-  }
-
-  static getConnectionInstanceEntityByName(domain: Domain, name: string): any {
-    const connection = ConnectionManager.entities[domain.id]?.[name]
-    if (connection) {
-      return connection
-    }
-
-    if (domain.parentId) {
-      return ConnectionManager.entities[domain.id]?.[name]
-    }
-  }
-
-  static getConnectionInstances(domain: Domain): { [connectionName: string]: any } {
-    const connections = ConnectionManager.connections[domain.id]
-    const parentConnections = domain.parentId && ConnectionManager.connections[domain.parentId]
-
-    return {
-      ...parentConnections,
-      ...connections
-    }
-  }
-
-  static getConnectionInstanceEntities(domain: Domain): { [connectionName: string]: any } {
-    const connections = ConnectionManager.entities[domain.id]
-
-    return {
-      ...connections
-    }
-  }
-
-  static addConnectionInstance(connection: Connection, instance: any) {
-    const { domain, name } = connection
-
-    var connections = ConnectionManager.connections[domain.id]
-    if (!connections) {
-      connections = ConnectionManager.connections[domain.id] = {}
-    }
-
-    var entities = ConnectionManager.entities[domain.id]
-    if (!entities) {
-      entities = ConnectionManager.entities[domain.id] = {}
-    }
-
-    connections[name] = instance
-    entities[name] = connection
-
-    ConnectionManager.publishState(connection, ConnectionStatus.CONNECTED)
-    debug('add-connection', domain.subdomain, name)
-  }
-
-  static removeConnectionInstance(connection: Connection): any {
-    const { domain, name } = connection
-    var connections = ConnectionManager.connections[domain.id]
-    var entities = ConnectionManager.entities[domain.id]
-
-    var instance = connections?.[name]
-
-    if (!connections || !instance) {
-      debug('remove-connection', `'${name}' connection not found in domain '${domain.subdomain}'`)
-      return
-    }
-
-    delete connections[name]
-    delete entities[name]
-
-    ConnectionManager.publishState(connection, ConnectionStatus.DISCONNECTED)
-    debug('remove-connection', `'${name}' connection is removed from domain '${domain.subdomain}'`)
-
-    return instance
-  }
-
-  private static async publishState(connection: Connection, state) {
-    const { domain, id, name, description, type, edge } = connection
-
-    pubsub.publish('connection-state', {
-      connectionState: {
-        domain,
-        id,
-        name,
-        description,
-        type,
-        edge,
-        state,
-        timestamp: new Date()
-      }
-    })
-  }
-}

package/server/engine/connector/echo-back-connector.ts

@@ -1,51 +0,0 @@
-import net from 'net'
-import PromiseSocket from 'promise-socket'
-
-import { Connector } from '../types'
-import { ConnectionManager } from '../connection-manager'
-import { InputConnection } from '../../service/connection/connection-type'
-
-export class EchoBack implements Connector {
-  async ready(connectionConfigs) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-
-    ConnectionManager.logger.info('echo-back connections are ready')
-  }
-
-  async connect(connection: InputConnection) {
-    let socket = new PromiseSocket(new net.Socket())
-    let [host, port = 8124] = connection.endpoint.split(':')
-
-    try {
-      await socket.connect(Number(port), host)
-      ConnectionManager.addConnectionInstance(connection, socket)
-
-      ConnectionManager.logger.info(
-        `echo-back-connector connection(${connection.name}:${connection.endpoint}) is connected`
-      )
-    } catch (e) {
-      ConnectionManager.logger.error(
-        `echo-back-connector connection(${connection.name}:${connection.endpoint}) is not connected.`,
-        e
-      )
-    }
-  }
-
-  async disconnect(connection: InputConnection) {
-    let socket = ConnectionManager.removeConnectionInstance(connection)
-
-    await socket.destroy()
-
-    ConnectionManager.logger.info(`echo-back-connector connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return []
-  }
-
-  get taskPrefixes() {
-    return ['echo']
-  }
-}
-
-ConnectionManager.registerConnector('echo-back', new EchoBack())

package/server/engine/connector/echo-back-server.ts

@@ -1,72 +0,0 @@
-import net from 'net'
-import PromiseSocket from 'promise-socket'
-
-import { Connector } from '../types'
-import { ConnectionManager } from '../connection-manager'
-import { InputConnection } from '../../service/connection/connection-type'
-
-export class EchoBack implements Connector {
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-
-    ConnectionManager.logger.info('echo-back-servers are ready')
-  }
-
-  async connect(config: InputConnection): Promise<void> {
-    var [host = '0.0.0.0', port = 8124] = config.endpoint.split(':')
-
-    return new Promise((resolve, reject) => {
-      var server = net.createServer(socket => {
-        socket.on('data', function (data) {
-          socket.write(data.toString())
-        })
-
-        socket.on('error', function (err) {
-          ConnectionManager.logger.error(err)
-          reject(err)
-        })
-      })
-
-      server.listen(port, async () => {
-        ConnectionManager.logger.info(`Echo-back server listening on ${host}:${port}`)
-
-        /* default client connection */
-        let socket = new net.Socket()
-        socket.on('error', console.error)
-
-        try {
-          let promiseSocket = new PromiseSocket(socket)
-          await promiseSocket.connect(Number(port), 'localhost')
-          promiseSocket['__server__'] = server
-
-          ConnectionManager.addConnectionInstance(config, promiseSocket)
-
-          ConnectionManager.logger.info(`echo-back-server connection(${config.name}:${config.endpoint}) is connected`)
-
-          resolve()
-        } catch (err) {
-          ConnectionManager.logger.error(
-            `echo-back-server connection(${config.name}:${config.endpoint}) is connected.\ncause: ${err}`
-          )
-          reject(err)
-        }
-      })
-    })
-  }
-
-  async disconnect(connection: InputConnection) {
-    let socket = ConnectionManager.removeConnectionInstance(connection)
-    var server = socket['__server__']
-
-    await socket.destroy()
-    server && (await server.close())
-
-    ConnectionManager.logger.info(`echo-back-server connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return []
-  }
-}
-
-ConnectionManager.registerConnector('echo-back-server', new EchoBack())