@things-factory/integration-base 7.0.0-alpha.1 → 7.0.0-alpha.21

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

@@ -23,10 +23,6 @@ const defaultOptions: any = {
   }
 }
 
-const cache = new InMemoryCache({
-  addTypename: false
-})
-
 export class GraphqlConnector implements Connector {
   async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
@@ -35,12 +31,12 @@ export class GraphqlConnector implements Connector {
   }
 
   async connect(connection: InputConnection) {
-    var {
+    const {
       endpoint: uri,
       params: { authClient }
     } = connection
 
-    var ERROR_HANDLER: any = ({ graphQLErrors, networkError }) => {
+    const ERROR_HANDLER: any = ({ graphQLErrors, networkError }) => {
       if (graphQLErrors)
         graphQLErrors.map(({ message, locations, path }) => {
           ConnectionManager.logger.error(`[GraphQL error] Message: ${message}, Location: ${locations}, Path: ${path}`)
@@ -65,6 +61,10 @@ export class GraphqlConnector implements Connector {
       return forward(operation)
     })
 
+    const cache = new InMemoryCache({
+      addTypename: false
+    })
+
     ConnectionManager.addConnectionInstance(
       connection,
       new ApolloClient({
@@ -81,13 +81,11 @@ export class GraphqlConnector implements Connector {
       })
     )
 
-    ConnectionManager.logger.info(
-      `graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`
-    )
+    ConnectionManager.logger.info(`graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`)
   }
 
   async disconnect(connection: InputConnection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
+    const client = ConnectionManager.getConnectionInstance(connection)
     client.stop()
     ConnectionManager.removeConnectionInstance(connection)
 

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

@@ -3,7 +3,6 @@ import 'cross-fetch/polyfill'
 import { ApolloClient, InMemoryCache, createHttpLink, split } from '@apollo/client/core'
 import { setContext } from '@apollo/client/link/context'
 
-// for subscription
 import WebSocket from 'ws'
 import { createClient } from 'graphql-ws'
 import { GraphQLWsLink } from '@apollo/client/link/subscriptions'
@@ -20,7 +19,7 @@ import { ScenarioInstance } from '../../service/scenario-instance/scenario-insta
 import { getRepository, GraphqlLocalClient, Domain } from '@things-factory/shell'
 import { User, checkPermission } from '@things-factory/auth-base'
 
-const debug = require('debug')('things-factory:integration-base:operato-connector-subscription')
+const debug = require('debug')('things-factory:integration-base:operato-connector')
 
 const defaultOptions: any = {
   watchQuery: {
@@ -36,10 +35,6 @@ const defaultOptions: any = {
   }
 }
 
-const cache = new InMemoryCache({
-  addTypename: false
-})
-
 export const GRAPHQL_URI = '/graphql'
 export const SUBSCRIPTION_URI = GRAPHQL_URI
 
@@ -48,7 +43,6 @@ interface SubscriberData {
   scenario: any
   subscriptionObserver: any
 }
-;``
 
 export class OperatoConnector implements Connector {
   private context: any
@@ -56,11 +50,11 @@ export class OperatoConnector implements Connector {
   async ready(connectionConfigs: InputConnection[]) {
     await Promise.all(connectionConfigs.map(this.connect.bind(this)))
 
-    ConnectionManager.logger.info('graphql-connector connections are ready')
+    ConnectionManager.logger.info('operato-connector connections are ready')
   }
 
   async connect(connection: InputConnection) {
-    var {
+    const {
       endpoint: uri,
       params: { authKey, domain, subscriptionHandlers = {} }
     } = connection
@@ -69,7 +63,7 @@ export class OperatoConnector implements Connector {
       throw new Error('some connection paramter missing.')
     }
 
-    var domainOwner = await getRepository(User).findOne({
+    const domainOwner = await getRepository(User).findOne({
       where: {
         id: connection.domain.owner
       }
@@ -125,20 +119,24 @@ export class OperatoConnector implements Connector {
       }).concat(httpLink)
     )
 
-    var client = new ApolloClient({
+    const cache = new InMemoryCache({
+      addTypename: false
+    })
+
+    const client = new ApolloClient({
       defaultOptions,
       cache,
       link: splitLink
     })
 
-    var subscriptions: SubscriberData[] = []
+    const subscriptions: SubscriberData[] = []
     Object.keys(subscriptionHandlers).forEach(async tag => {
       if (!tag || !subscriptionHandlers[tag]) return
 
-      let scenarioName = subscriptionHandlers[tag]
+      const scenarioName = subscriptionHandlers[tag]
 
       // fetch a scenario
-      var selectedScenario = await getRepository(Scenario).findOne({
+      const selectedScenario = await getRepository(Scenario).findOne({
         where: {
           name: scenarioName
         },
@@ -156,7 +154,7 @@ export class OperatoConnector implements Connector {
         `
       })
 
-      var subscriptionObserver = subscription.subscribe({
+      const subscriptionObserver = subscription.subscribe({
         next: async data => {
           debug('received pubsub msg.:', data?.data)
           await this.runScenario(subscriptions, data?.data?.data)
@@ -169,9 +167,7 @@ export class OperatoConnector implements Connector {
         }
       })
 
-      ConnectionManager.logger.info(
-        `(${connection.name}:${connection.endpoint}) subscription closed flag: ${subscriptionObserver.closed}`
-      )
+      ConnectionManager.logger.info(`(${connection.name}:${connection.endpoint}) subscription closed flag: ${subscriptionObserver.closed}`)
 
       subscriptions.push({
         tag,
@@ -184,19 +180,17 @@ export class OperatoConnector implements Connector {
     client['subscriptions'] = subscriptions
     ConnectionManager.addConnectionInstance(connection, client)
 
-    ConnectionManager.logger.info(
-      `graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`
-    )
+    ConnectionManager.logger.info(`operato-connector connection(${connection.name}:${connection.endpoint}) is connected`)
   }
 
   async disconnect(connection: InputConnection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
-    let subscriptions: SubscriberData[] = client['subscriptions']
+    const client = ConnectionManager.getConnectionInstance(connection)
+    const subscriptions: SubscriberData[] = client['subscriptions']
     subscriptions.forEach(subscription => subscription.subscriptionObserver.unsubscribe())
     client.stop()
     ConnectionManager.removeConnectionInstance(connection)
 
-    ConnectionManager.logger.info(`graphql-connector connection(${connection.name}) is disconnected`)
+    ConnectionManager.logger.info(`operato-connector connection(${connection.name}) is disconnected`)
   }
 
   async runScenario(subscriptions: SubscriberData[], variables: any): Promise<ScenarioInstance> {
@@ -207,23 +201,19 @@ export class OperatoConnector implements Connector {
       throw new Error(`tag is invalid - ${tag}`)
     }
 
-    var scenario = subscriptions.find(subscription => subscription.tag === tag)?.scenario
+    const scenario = subscriptions.find(subscription => subscription.tag === tag)?.scenario
     if (!scenario) {
       throw new Error(`scenario is not found - ${tag}`)
     }
 
     if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
       const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
+      throw new Error(`Unauthorized! ${category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'} required`)
     }
 
     /* create a scenario instance */
-    let instanceName = scenario.name + '-' + String(Date.now())
-    var instance = new ScenarioInstance(instanceName, scenario, {
+    const instanceName = scenario.name + '-' + String(Date.now())
+    const instance = new ScenarioInstance(instanceName, scenario, {
       user,
       domain,
       variables,

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

@@ -4,9 +4,8 @@ import { ConnectionManager } from '../connection-manager'
 import { Connector } from '../types'
 import { InputConnection } from '../../service/connection/connection-type'
 
-
 try {
-  var Client = require('oracledb')
+  var oracledb = require('oracledb')
 } catch (err) {
   logger.error('oracledb module loading failed')
 }
@@ -18,42 +17,132 @@ export class OracleConnector implements Connector {
     ConnectionManager.logger.info('oracle-connector connections are ready')
   }
 
-  async connect(connection: InputConnection) {
+  async recreatePool(connection: InputConnection) {
     const {
+      name,
       endpoint,
-      params: { user, password, database }
+      params: { user, password, database, poolMin, poolMax, poolIncrement },
+      domain
     } = connection
 
-    if (!Client) {
+    if (!oracledb) {
       throw new Error('oracledb module loading failed')
     }
 
-    //when oracle not using default port must add connection string with port like localhsot:port
-    const client = await Client.getConnection({
+    const poolAlias = `${domain.name}-${name}`
+    await oracledb.getPool(poolAlias).close(10)
+    await oracledb.createPool({
       user,
       password,
-      connectString: `${endpoint.trim()}/${database}`
+      // 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) => {
-        return (
-          await client.execute(query, params, {
-            outFormat: Client.OBJECT
-          })
-        ).rows
+        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) => {
-        // TODO: need to check if this is available when procedure string is a common query.
-        procedure = `BEGIN
-          ${procedure}
-        END;`
-
-        return await client.execute(procedure, params, {
-          outFormat: Client.OBJECT
-        })
+        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: client.close.bind(client)
+      close: async () => {
+        await oracledb.getPool(poolAlias).close(10)
+      }
     })
 
     ConnectionManager.logger.info(`Oracle Database(${connection.name}:${database}) at ${endpoint} connected.`)
@@ -89,6 +178,27 @@ export class OracleConnector implements Connector {
         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
       }
     ]
   }

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

@@ -0,0 +1,53 @@
+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/edge-client.ts

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

@@ -5,5 +5,6 @@ export * from './connection-manager'
 export * from './scenario-engine'
 export * from './task-registry'
 export * from './analyzer/analyze-integration'
+export * from './edge-client'
 
 export { Connector } from './types'

package/server/engine/task/oracle-procedure.ts

@@ -97,23 +97,8 @@ async function OracleProcedure(step: InputStep, context: Context) {
 
   const result = await dbconnection.execute(code, procedureParameters)
 
-  var taskResult = {}
-  let paramKeys = Object.keys(procedureParameters)
-
-  for (const paramKey of paramKeys) {
-    if (procedureParameters[paramKey].dir === oracledb?.BIND_OUT) {
-      if (procedureParameters[paramKey].type === oracledb?.CURSOR) {
-        const resultSetTemp = result.outBinds[paramKey]
-        taskResult[paramKey] = await resultSetTemp.getRows()
-        await resultSetTemp.close()
-      } else {
-        taskResult[paramKey] = result.outBinds[paramKey]
-      }
-    }
-  }
-
   return {
-    data: taskResult
+    data: result
   }
 }
 

package/server/engine/task/script.ts

@@ -19,6 +19,7 @@ async function Script(step: InputStep, context: Context) {
       domain,
       user,
       lng,
+      logger,
       data,
       variables
     }

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

@@ -55,7 +55,7 @@ async function initializeChromium() {
 
     var launchSetting = {
       args: ['--mute-audio', '--no-sandbox'],
-      headless: 'new'
+      headless: 'shell'
     }
 
     if (CHROMIUM_PATH) {

package/server/engine/types.ts

@@ -13,79 +13,79 @@ export interface Connector {
 }
 
 export type Context = {
-  /** 
-    * Represents the domain context.
-    */
+  /**
+   * Represents the domain context.
+   */
   domain: Domain
 
-  /** 
-    * User information.
-    */
+  /**
+   * User information.
+   */
   user: User
 
-  /** 
-    * Language code, for example 'en', 'ko'.
-    */
+  /**
+   * Language code, for example 'en', 'ko'.
+   */
   lng: string
 
-  /** 
-    * Flag to indicate if the IP is unsafe, can be undefined.
-    */
+  /**
+   * Flag to indicate if the IP is unsafe, can be undefined.
+   */
   unsafeIP: boolean | undefined
 
-  /** 
-    * List of prohibited privileges, can be undefined.
-    */
+  /**
+   * List of prohibited privileges, can be undefined.
+   */
   prohibitedPrivileges: { category: string; privilege: string }[] | undefined
 
-  /** 
-    * Logger for logging purposes.
-    */
+  /**
+   * Logger for logging purposes.
+   */
   logger: any
 
-  /** 
-    * Function to publish events or messages.
-    */
+  /**
+   * Function to publish events or messages.
+   */
   publish: Function
 
-  /** 
-    * Function to load resources or data.
-    */
+  /**
+   * Function to load resources or data.
+   */
   load: Function
 
-  /** 
-    * Current status of the scenario instance.
-    */
+  /**
+   * Current status of the scenario instance.
+   */
   state: ScenarioInstanceStatus
 
-  /** 
-    * General data storage object.
-    */
+  /**
+   * General data storage object.
+   */
   data: any
 
-  /** 
-    * Variables related to the context.
-    */
+  /**
+   * Variables related to the context.
+   */
   variables: Object
 
-  /** 
-    * Local GraphQL client object.
-    */
+  /**
+   * Local GraphQL client object.
+   */
   client: any /* graphql local client */
 
-  /** 
-    * Root object, can be used for various purposes.
-    */
+  /**
+   * Root object, can be used for various purposes.
+   */
   root: Object
 
-  /** 
-    * Array of function closures.
-    */
+  /**
+   * Array of function closures.
+   */
   closures: Function[]
 
-  /** 
-    * Function to check the state.
-    */
+  /**
+   * Function to check the state.
+   */
   checkState: Function
 
   /**
@@ -104,7 +104,6 @@ export type Context = {
   __csv_resources?: any
 }
 
-
 export type TaskHandler = (
   step: Step,
   context: Context