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

package/server/engine/connector/oracle-connector.ts

@@ -1,218 +0,0 @@
-import { logger } from '@things-factory/env'
-
-import { ConnectionManager } from '../connection-manager'
-import { Connector } from '../types'
-import { InputConnection } from '../../service/connection/connection-type'
-
-try {
-  var oracledb = require('oracledb')
-} catch (err) {
-  logger.error('oracledb module loading failed', err)
-}
-
-export class OracleConnector implements Connector {
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect))
-
-    ConnectionManager.logger.info('oracle-connector connections are ready')
-  }
-
-  async recreatePool(connection: InputConnection) {
-    const {
-      name,
-      endpoint,
-      params: { user, password, database, poolMin, poolMax, poolIncrement },
-      domain
-    } = connection
-
-    if (!oracledb) {
-      throw new Error('oracledb module loading failed')
-    }
-
-    const poolAlias = `${domain.name}-${name}`
-    await oracledb.getPool(poolAlias).close(10)
-    await oracledb.createPool({
-      user,
-      password,
-      // when oracle not using default port must add connection string with port like localhost:port
-      connectString: `${endpoint.trim()}/${database}`,
-      poolMin,
-      poolMax,
-      poolIncrement,
-      poolAlias
-    })
-
-    ConnectionManager.logger.info(`Oracle Database(${connection.name}:${database}) at ${endpoint} recreated.`)
-  }
-
-  async connect(connection: InputConnection) {
-    const {
-      name,
-      endpoint,
-      params: { user, password, database, poolMin, poolMax, poolIncrement },
-      domain
-    } = connection
-
-    if (!oracledb) {
-      throw new Error('oracledb module loading failed')
-    }
-
-    const poolAlias = `${domain.name}-${name}`
-
-    var enableStatistics = true
-    const pool = await oracledb.createPool({
-      user,
-      password,
-      // when oracle not using default port must add connection string with port like localhost:port
-      connectString: `${endpoint.trim()}/${database}`,
-      poolMin,
-      poolMax,
-      poolIncrement,
-      poolAlias,
-      enableStatistics
-    })
-
-    ConnectionManager.addConnectionInstance(connection, {
-      query: async (query, params) => {
-        let dbConnection: any = {}
-        let taskResult: any = {}
-        try {
-          dbConnection = await oracledb.getConnection(poolAlias)
-
-          taskResult = (
-            await dbConnection.execute(query, params, {
-              outFormat: oracledb.OBJECT
-            })
-          ).rows
-        } catch (e) {
-          if (e.name === 'Error' && e.message.includes('NJS-040')) {
-            await this.recreatePool(connection)
-          }
-          throw e
-        } finally {
-          await dbConnection.close()
-        }
-        return taskResult
-      },
-      execute: async (procedure, params) => {
-        let dbConnection: any = {}
-        let taskResult: any = {}
-        try {
-          // TODO: need to check if this is available when procedure string is a common query.
-          procedure = `BEGIN
-            ${procedure}
-          END;`
-          dbConnection = await oracledb.getConnection(poolAlias)
-
-          // console.log('\n************* stat after get ****************')
-          // await oracledb.getPool(poolAlias).logStatistics()
-
-          const result = await dbConnection.execute(procedure, params, {
-            outFormat: oracledb.OBJECT
-          })
-
-          let paramKeys = Object.keys(params)
-
-          for (const paramKey of paramKeys) {
-            if (params[paramKey].dir === oracledb?.BIND_OUT) {
-              if (params[paramKey].type === oracledb?.CURSOR) {
-                const resultSetTemp = result.outBinds[paramKey]
-                taskResult[paramKey] = await resultSetTemp.getRows()
-                await resultSetTemp.close()
-              } else {
-                taskResult[paramKey] = result.outBinds[paramKey]
-              }
-            }
-          }
-        } catch (e) {
-          if (e.name === 'Error' && e.message.includes('NJS-040')) {
-            await this.recreatePool(connection)
-          }
-          throw e
-        } finally {
-          await dbConnection.close()
-
-          // console.log('\n************* stat after close ****************')
-          // await oracledb.getPool(poolAlias).logStatistics()
-        }
-        return taskResult
-      },
-      close: async () => {
-        await oracledb.getPool(poolAlias).close(10)
-      }
-    })
-
-    ConnectionManager.logger.info(`Oracle Database(${connection.name}:${database}) at ${endpoint} connected.`)
-  }
-
-  async disconnect(connection: InputConnection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
-
-    try {
-      await client.close()
-      ConnectionManager.logger.info(`Oracle Database(${connection.name}) closed.`)
-    } catch (e) {
-      ConnectionManager.logger.error(e)
-    }
-
-    ConnectionManager.removeConnectionInstance(connection)
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'string',
-        name: 'user',
-        label: 'user'
-      },
-      {
-        type: 'password',
-        name: 'password',
-        label: 'password'
-      },
-      {
-        type: 'string',
-        name: 'database',
-        placeholder: 'SID',
-        label: 'database'
-      },
-      {
-        type: 'number',
-        name: 'poolMin',
-        placeholder: 'minimum connection-pool size',
-        label: 'pool-min',
-        value: 0
-      },
-      {
-        type: 'number',
-        name: 'poolMax',
-        placeholder: 'maximum connection-pool size',
-        label: 'pool-max',
-        value: 4
-      },
-      {
-        type: 'number',
-        name: 'poolIncrement',
-        placeholder: 'connection incremental size',
-        label: 'pool-increment',
-        value: 1
-      }
-    ]
-  }
-
-  get taskPrefixes() {
-    return ['database', 'oracle']
-  }
-
-  get help() {
-    return 'integration/connector/oracle-connector'
-  }
-}
-
-ConnectionManager.registerConnector('oracle-connector', new OracleConnector())
-
-// need reference:
-// https://download.oracle.com/otn_software/mac/instantclient/193000/instantclient-basiclite-macos.x64-19.3.0.0.0dbru.zip
-// https://node-oracledb.readthedocs.io/en/latest/index.html
-
-// docker pull store/oracle/database-instantclient:12.2.0.1

package/server/engine/connector/postgresql-connector.ts

@@ -1,152 +0,0 @@
-import { logger } from '@things-factory/env'
-
-import { ConnectionManager } from '../connection-manager'
-import { Connector } from '../types'
-import { InputConnection } from '../../service/connection/connection-type'
-
-try {
-  var { Client, Pool } = require('pg')
-} catch (err) {
-  logger.error('postgresql module loading failed', err)
-}
-
-export class PostgresqlConnector implements Connector {
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-
-    ConnectionManager.logger.info('postgresql-connector connections are ready')
-  }
-
-  async connect(connection: InputConnection) {
-    const {
-      endpoint,
-      params: { user, password, database, maxPoolConnection, idleTimeoutMillis, connectionTimeoutMillis }
-    } = connection
-    const [host, port = 5432] = endpoint.split(':')
-
-    if (!Pool) {
-      throw new Error('postgresql module loading failed')
-    }
-
-    // create a new pool
-    const pool = new Pool({
-      user,
-      host,
-      database,
-      password,
-      port: Number(port),
-      max: maxPoolConnection || 10,
-      idleTimeoutMillis: idleTimeoutMillis || 30000,
-      connectionTimeoutMillis: connectionTimeoutMillis || 2000
-    })
-
-    pool.on('error', (err, client) => {
-      logger.error('unexpected error on postgres pool.', err)
-    })
-
-    try {
-      // try to connect to database to check the connection at initial time
-      const entryConnection = await pool.connect().catch(async e => {
-        ConnectionManager.logger.error(e)
-        throw e
-      })
-      entryConnection.release()
-
-      ConnectionManager.addConnectionInstance(connection, {
-        query: async (query, params) => {
-          try {
-            // get a connection from the pool
-            var client = await pool.connect().catch(async e => {
-              ConnectionManager.logger.error(e)
-              throw e
-            })
-
-            client?.on('error', async err => {
-              logger.error('unexpected error on postgres client.', err)
-              ConnectionManager.logger.error(err)
-            })
-
-            // try to query
-            var result = (await client.query(query, params)).rows
-          } catch (e) {
-            ConnectionManager.logger.error(e)
-            throw e
-          } finally {
-            // release the connection back to the pool
-            client?.release()
-          }
-          return result
-        },
-        close: async () => {
-          // close the pool
-          await pool?.end()
-        }
-      })
-
-      ConnectionManager.logger.info(`PostgresSQL Database(${connection.name}:${database}) at ${endpoint} connected.`)
-    } catch (e) {
-      ConnectionManager.logger.error(
-        `PostgresSQL Database(${connection.name}:${database}) at ${endpoint} not connected.`,
-        e
-      )
-    }
-  }
-
-  async disconnect(connection: InputConnection) {
-    var connectionInstance = ConnectionManager.getConnectionInstance(connection)
-    try {
-      await connectionInstance.close()
-      ConnectionManager.logger.info(`PostgresSQL Database(${connection.name}) closed.`)
-    } catch (e) {
-      ConnectionManager.logger.error(e)
-    }
-    ConnectionManager.removeConnectionInstance(connection)
-  }
-
-  get parameterSpec() {
-    return [
-      {
-        type: 'string',
-        name: 'user',
-        label: 'user'
-      },
-      {
-        type: 'password',
-        name: 'password',
-        label: 'password'
-      },
-      {
-        type: 'string',
-        name: 'database',
-        label: 'database'
-      },
-      {
-        type: 'number',
-        name: 'maxPoolConnection',
-        label: 'maxPoolConnection'
-      },
-      {
-        type: 'number',
-        name: 'idleTimeoutMillis',
-        label: 'idleTimeoutMillis',
-        placeHolder: 'milli-seconds'
-      },
-      {
-        type: 'number',
-        name: 'connectionTimeoutMillis',
-        label: 'connectionTimeoutMillis',
-        placeHolder: 'milli-seconds'
-      }
-    ]
-  }
-
-  get taskPrefixes() {
-    return ['database']
-  }
-
-  get help() {
-    return 'integration/connector/postgresql-connector'
-  }
-}
-
-ConnectionManager.registerConnector('postgresql-connector', new PostgresqlConnector())

package/server/engine/connector/proxy-connector.ts

@@ -1,53 +0,0 @@
-import { ConnectionManager } from '../connection-manager'
-import { Connector } from '../types'
-import { InputConnection } from '../../service/connection/connection-type'
-import { connectConnections, disconnectConnections } from '../edge-client'
-
-/**
- * This connector is a proxy connector installed on the edge server to manage connections from the host.
- * It interacts with connections established on the edge server and provides synchronization functionality.
- */
-export class ProxyConnector implements Connector {
-  public static instance = new ProxyConnector()
-
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-
-    ConnectionManager.logger.info('proxy-connector connections are ready')
-  }
-
-  async connect(connection: InputConnection) {
-    // TODO 원래 커넥션과 에지설정을 참고하여, 에지 서버로 CONNECT/DISCONNECT 명령을 보낸다.
-    const proxy = {
-      disconnect: async () => {
-        ConnectionManager.logger.info('[proxy-connector] trying disconnect')
-        await disconnectConnections([connection])
-      }
-    }
-
-    await connectConnections([connection])
-
-    ConnectionManager.addConnectionInstance(connection, proxy)
-
-    ConnectionManager.logger.info(`proxy-connector connection(${connection.name}:${connection.endpoint}) is connected`)
-  }
-
-  async disconnect(connection: InputConnection) {
-    const proxy = ConnectionManager.removeConnectionInstance(connection)
-    await proxy.disconnect()
-
-    ConnectionManager.logger.info(`proxy-connector connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return []
-  }
-
-  get taskPrefixes() {
-    return []
-  }
-
-  get description() {
-    return 'Operato Proxy Connector'
-  }
-}

package/server/engine/connector/socket-server.ts

@@ -1,86 +0,0 @@
-import net from 'net'
-import { EventEmitter } from 'events'
-
-import { Connector } from '../types'
-import { ConnectionManager } from '../connection-manager'
-import { InputConnection } from '../../service/connection/connection-type'
-
-export class SocketServer implements Connector {
-  // socket: any
-
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect))
-    ConnectionManager.logger.info('socket servers are ready')
-  }
-
-  async connect(config: InputConnection): Promise<void> {
-    var em = new EventEmitter()
-    var [host = '0.0.0.0', port = 8124] = config.endpoint.split(':')
-    return new Promise((resolve, reject) => {
-      var server = net.createServer(tcp => {
-        ConnectionManager.logger.info('Client connection: ')
-        ConnectionManager.logger.info('   local = %s:%s', tcp.localAddress, tcp.localPort)
-        ConnectionManager.logger.info('   remote = %s:%s', tcp.remoteAddress, tcp.remotePort)
-        tcp.on('data', (data: any) => {
-          em['__tcp__'] = tcp
-          var message = data.toString()
-          message = message.replace('SB#', '')
-          message = message.replace(/(\r\n|\n|\r)/gm, '')
-          em.emit('socket-message-arrive', message)
-          ConnectionManager.logger.info(`socket ${message}`)
-          tcp.write('ok')
-        })
-
-        tcp.on('end', () => {
-          ConnectionManager.logger.info('Client disconnected')
-        })
-
-        tcp.on('error', ex => {
-          ConnectionManager.logger.info('Server socket error: ')
-          var logger = ConnectionManager.logger
-          let message = ex.stack ? ex.stack : ex
-          let msg = typeof message == 'object' ? JSON.stringify(message, null, 2) : message
-          logger.error(msg, ex)
-          reject(ex)
-        })
-      })
-
-      server.listen(port, async () => {
-        ConnectionManager.logger.info(`tcp echo server listening on ${host}:${port}`)
-
-        /* default client connection */
-        try {
-          em['__server__'] = server
-          ConnectionManager.addConnectionInstance(config, em)
-          ConnectionManager.logger.info(`socket server connection(${config.name}:${config.endpoint}) is connected`)
-
-          resolve()
-        } catch (err) {
-          ConnectionManager.logger.error(err)
-          reject(err)
-        }
-      })
-    })
-  }
-
-  async disconnect(connection: InputConnection) {
-    let em = ConnectionManager.removeConnectionInstance(connection)
-    var tcp = em['__tcp__']
-    var server = em['__server__']
-
-    tcp && (await tcp.destroy())
-    server && (await server.close())
-
-    ConnectionManager.logger.info(`socket server connection(${connection.name}) is disconnected`)
-  }
-
-  get parameterSpec() {
-    return []
-  }
-
-  get taskPrefixes() {
-    return ['socket']
-  }
-}
-
-ConnectionManager.registerConnector('socket-server', new SocketServer())

package/server/engine/connector/sqlite-connector.ts

@@ -1,69 +0,0 @@
-import { promisify } from 'util'
-
-import { logger } from '@things-factory/env'
-
-import { ConnectionManager } from '../connection-manager'
-import { Connector } from '../types'
-import { InputConnection } from '../../service/connection/connection-type'
-
-try {
-  var sqlite3 = require('sqlite3').verbose()
-} catch (err) {
-  logger.error('sqlite3 module loading failed', err)
-}
-
-export class SqliteConnector implements Connector {
-  async ready(connectionConfigs: InputConnection[]) {
-    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
-
-    ConnectionManager.logger.info('sqlite-connector connections are ready')
-  }
-
-  async connect(connection: InputConnection) {
-    var { endpoint } = connection
-
-    if (!sqlite3) {
-      throw new Error('sqlite3 module loading failed')
-    }
-
-    var database = new sqlite3.Database(endpoint, sqlite3.OPEN_READWRITE, err => {
-      if (err) {
-        ConnectionManager.logger.error(`SQLite Database(${connection.name}) at ${endpoint} not connected.`, err)
-        return
-      }
-
-      ConnectionManager.addConnectionInstance(connection, {
-        query: promisify(database.all.bind(database)),
-        close: promisify(database.close.bind(database))
-      })
-
-      ConnectionManager.logger.info(`SQLite Database(${connection.name}) at ${endpoint} connected.`)
-    })
-  }
-
-  async disconnect(connection: InputConnection) {
-    var database = ConnectionManager.getConnectionInstance(connection)
-    try {
-      await database.close()
-      ConnectionManager.logger.info(`SQLite Database(${connection.name}) closed.`)
-    } catch (e) {
-      ConnectionManager.logger.error(e)
-    }
-
-    ConnectionManager.removeConnectionInstance(connection)
-  }
-
-  get parameterSpec() {
-    return []
-  }
-
-  get taskPrefixes() {
-    return ['database']
-  }
-
-  get help() {
-    return 'integration/connector/sqlite-connector'
-  }
-}
-
-ConnectionManager.registerConnector('sqlite-connector', new SqliteConnector())

package/server/engine/edge-client.ts

@@ -1,45 +0,0 @@
-import { Connection } from '../service/connection/connection-type'
-import { Step } from '../service/step/step-type'
-import { Context, TaskHandler } from './types'
-
-export type EdgeClient = {
-  handler: TaskHandler
-  syncConnections(connections: Connection[], context?: ResolverContext): Promise<any>
-  connectConnections(connections: Connection[], context?: ResolverContext): Promise<any>
-  disconnectConnections(connections: Connection[], context?: ResolverContext): Promise<any>
-}
-
-var edgeClient: EdgeClient = {
-  async handler(step: Step, scenarioContext: Context) {
-    throw 'edgeClient not supported'
-  },
-  async syncConnections(connections: Connection[], context: ResolverContext): Promise<any> {
-    throw 'edgeClient not supported'
-  },
-  async connectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
-    throw 'edgeClient not supported'
-  },
-  async disconnectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
-    throw 'edgeClient not supported'
-  }
-}
-
-export async function handler(step: Step, scenarioContext: Context) {
-  return await edgeClient.handler(step, scenarioContext)
-}
-
-export async function syncConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
-  return await edgeClient.syncConnections(connections, context)
-}
-
-export async function connectConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
-  return await edgeClient.connectConnections(connections, context)
-}
-
-export async function disconnectConnections(connections: Connection[], context?: ResolverContext): Promise<any> {
-  return await edgeClient.disconnectConnections(connections, context)
-}
-
-export function setEdgeClient(edge: EdgeClient) {
-  edgeClient = edge
-}

package/server/engine/index.ts

@@ -1,11 +0,0 @@
-import './connector'
-import './task'
-
-export * from './connection-manager'
-export * from './scenario-engine'
-export * from './task-registry'
-export * from './analyzer/analyze-integration'
-export * from './edge-client'
-export * from './resource-pool'
-
-export { Connector, Context, TaskHandler } from './types'