@things-factory/integration-base 7.0.0-alpha.4 → 7.0.0-alpha.7

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/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/index.ts

@@ -1,5 +1,6 @@
 export * from './migrations'
 export * from './engine'
+export * from './controllers'
 export * from './service'
 
 import './routes'

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

@@ -1,7 +1,6 @@
 import gql from 'graphql-tag'
 
 import { restfulApiRouter as router } from '@things-factory/api'
-import { ScenarioInstanceStatus } from '../../service/scenario-instance/scenario-instance-type'
 
 const debug = require('debug')('things-factory:integration-base:restful:unstable:run-scenario')
 

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

@@ -12,7 +12,7 @@ router.post('/unstable/start-scenario/:scenarioName', async (context, next) => {
 
   context.body = await client.mutate({
     mutation: gql`
-      mutation($instanceName: String, $scenarioName: String!, $variables: Object) {
+      mutation ($instanceName: String, $scenarioName: String!, $variables: Object) {
         startScenario(instanceName: $instanceName, scenarioName: $scenarioName, variables: $variables) {
           instanceName
           scenarioName

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

@@ -11,7 +11,7 @@ router.post('/unstable/stop-scenario/:instanceName', async (context, next) => {
 
   context.body = await client.mutate({
     mutation: gql`
-      mutation($instanceName: String!) {
+      mutation ($instanceName: String!) {
         stopScenario(instanceName: $instanceName) {
           instanceName
           scenarioName

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

@@ -1,35 +1,14 @@
 import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
 
-import { getRepository, Domain, GraphqlLocalClient, ScalarObject } from '@things-factory/shell'
+import { ScalarObject } from '@things-factory/shell'
 
-import { ScenarioEngine } from '../../engine'
-import { Scenario } from '../scenario/scenario'
 import { ScenarioInstance } from './scenario-instance-type'
-import { PrivilegeObject, User, checkPermission } from '@things-factory/auth-base'
-import { Step } from '../step/step-type'
 
-const debug = require('debug')('things-factory:integration-base:scenario-instance-mutation')
-
-async function findScenario(
-  scenarioName: string,
-  domain: Domain
-): Promise<{ name: string; steps: Step[]; domain: Domain; privilege?: PrivilegeObject }> {
-  var repository = getRepository(Scenario)
-
-  var scenario = await repository.findOne({
-    where: { domain: { id: domain.id }, name: scenarioName },
-    relations: ['domain', 'steps', 'creator', 'updater']
-  })
-
-  if (!scenario && domain.parentId) {
-    scenario = await repository.findOne({
-      where: { domain: { id: domain.parentId }, name: scenarioName },
-      relations: ['domain', 'steps', 'creator', 'updater']
-    })
-  }
-
-  return scenario as any
-}
+import {
+  runScenario as controllerRunScenario,
+  startScenario as controllerStartScenario,
+  stopScenario as controllerStopScenario
+} from '../../controllers/scenario-controller'
 
 @Resolver(ScenarioInstance)
 export class ScenarioInstanceMutation {
@@ -42,42 +21,7 @@ export class ScenarioInstanceMutation {
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
-    const { domain, user, lng, unsafeIP, prohibitedPrivileges } = 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
-        })
-      )
-    }
-
-    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`
-      )
-    }
-
-    /* 시나리오 인스턴스를 생성한다. */
-    instanceName = instanceName || scenarioName + '-' + String(Date.now())
-    var instance = new ScenarioInstance(instanceName, scenario, {
-      domain,
-      user,
-      lng,
-      variables,
-      client: GraphqlLocalClient.client
-    })
-
-    await instance.run()
-
-    return instance
+    return await controllerRunScenario(instanceName, scenarioName, variables, context)
   }
 
   @Mutation(returns => ScenarioInstance, { description: 'To start new scenario instance' })
@@ -87,66 +31,11 @@ export class ScenarioInstanceMutation {
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
-    const { domain, user, lng, unsafeIP, prohibitedPrivileges } = 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
-        })
-      )
-    }
-
-    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`
-      )
-    }
-
-    instanceName = instanceName || scenarioName
-    return await ScenarioEngine.load(instanceName, scenario, { domain, user, lng, variables })
+    return await controllerStartScenario(instanceName, scenarioName, variables, context)
   }
 
   @Mutation(returns => ScenarioInstance, { nullable: true, description: 'To start new scenario instance' })
-  async stopScenario(
-    @Arg('instanceName', { nullable: true }) instanceName: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ScenarioInstance | undefined> {
-    const { domain, user, unsafeIP, prohibitedPrivileges } = context.state
-
-    debug('stopScenario', instanceName)
-
-    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)
-
-    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`
-      )
-    }
-
-    await ScenarioEngine.unload(domain, instanceName)
-
-    return scenarioInstance
+  async stopScenario(@Arg('instanceName', { nullable: true }) instanceName: string, @Ctx() context: ResolverContext): Promise<ScenarioInstance | undefined> {
+    return await controllerStopScenario(instanceName, context)
   }
 }

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

@@ -125,7 +125,7 @@ export class ScenarioInstance {
   timestamp: Date
 
   @Field({ nullable: true })
-  private message: string
+  public message: string
 
   private steps: Step[]
   private rounds: number = 0
@@ -267,10 +267,7 @@ export class ScenarioInstance {
       this.context.logger.error(ex.message ? ex.message : 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
-      )
+      this.setState(ScenarioInstanceStatus.HALTED, typeof message == 'object' ? JSON.stringify(message, null, 2) : message)
 
       throw ex
     }
@@ -376,9 +373,9 @@ export class ScenarioInstance {
       return
     }
 
-    this.message = `${this.instanceName}:[state changed] ${ScenarioInstanceStatus[this.getState()]} => ${
-      ScenarioInstanceStatus[state]
-    }${message ? ' caused by ' + util.inspect(message, false, 2, true) : ''}`
+    this.message = `${this.instanceName}:[state changed] ${ScenarioInstanceStatus[this.getState()]} => ${ScenarioInstanceStatus[state]}${
+      message ? ' caused by ' + util.inspect(message, false, 2, true) : ''
+    }`
 
     this.context.state = state
 
@@ -421,6 +418,12 @@ export class ScenarioInstance {
     if (this.disposer) {
       await this.disposer.call(this)
     }
+
+    // {{ CHECKPOINT 본 인스턴스를 위해서 생성된 logger를 닫는다.
+    if (this.context?.logger) {
+      this.context.logger.close()
+    }
+    // }}
   }
 
   async process(step, context): Promise<{ next: string; state: ScenarioInstanceStatus; data: object }> {