@things-factory/integration-base 7.0.0-alpha.8 → 7.0.0

package/server/engine/connection-manager.ts

@@ -5,8 +5,9 @@ import { Domain, getRepository, pubsub, PubSubLogTransport } from '@things-facto
 
 import { Connection, ConnectionStatus } from '../service'
 import { Connector } from './types'
+import { ProxyConnector } from './connector/proxy-connector'
 
-const { combine, timestamp, splat, printf } = format
+const { combine, splat, printf, errors } = format
 const debug = require('debug')('things-factory:integration-base:connections')
 
 const SYSTEM_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone
@@ -17,13 +18,14 @@ const systemTimestamp = format((info, opts) => {
 
 export class ConnectionManager {
   private static connectors: { [propName: string]: Connector } = {}
-  private static connections = {}
-  private static logFormat = printf(({ level, message, timestamp }) => {
-    return `${timestamp} ${level}: ${message}`
+  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(systemTimestamp({ tz: SYSTEM_TZ }), splat(), ConnectionManager.logFormat),
+    format: combine(errors({ stack: true }), systemTimestamp({ tz: SYSTEM_TZ }), splat(), ConnectionManager.logFormat),
     transports: [
       new (transports as any).DailyRotateFile({
         filename: `logs/connections-%DATE%.log`,
@@ -43,15 +45,14 @@ export class ConnectionManager {
     const CONNECTIONS = (
       await getRepository(Connection).find({
         where: { active: true },
-        relations: ['domain', 'creator', 'updater']
+        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`)
-        ConnectionManager.logger.error(ex)
+        ConnectionManager.logger.error(`connection '${connection.name}' params should be JSON format`, ex)
       }
 
       return {
@@ -63,14 +64,23 @@ export class ConnectionManager {
     ConnectionManager.logger.info('Initializing ConnectionManager...')
 
     return await Promise.all(
-      Object.keys(ConnectionManager.connectors).map(type => {
-        var connector = ConnectionManager.connectors[type]
+      [...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 => connection.type == type) as any)
+          .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.message)
+            ConnectionManager.logger.error(error)
           })
           .then(() => {
             ConnectionManager.logger.info(`All connector for '${type}' ready`)
@@ -103,6 +113,14 @@ export class ConnectionManager {
     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]
@@ -119,8 +137,29 @@ export class ConnectionManager {
     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
@@ -135,7 +174,13 @@ export class ConnectionManager {
       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)
@@ -144,6 +189,8 @@ export class ConnectionManager {
   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) {
@@ -152,6 +199,7 @@ export class ConnectionManager {
     }
 
     delete connections[name]
+    delete entities[name]
 
     ConnectionManager.publishState(connection, ConnectionStatus.DISCONNECTED)
     debug('remove-connection', `'${name}' connection is removed from domain '${domain.subdomain}'`)
@@ -159,8 +207,8 @@ export class ConnectionManager {
     return instance
   }
 
-  static publishState(connection: Connection, state) {
-    const { domain, id, name, description, type } = connection
+  private static async publishState(connection: Connection, state) {
+    const { domain, id, name, description, type, edge } = connection
 
     pubsub.publish('connection-state', {
       connectionState: {
@@ -169,6 +217,7 @@ export class ConnectionManager {
         name,
         description,
         type,
+        edge,
         state,
         timestamp: new Date()
       }

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

@@ -25,7 +25,8 @@ export class EchoBack implements Connector {
       )
     } catch (e) {
       ConnectionManager.logger.error(
-        `echo-back-connector connection(${connection.name}:${connection.endpoint}) is not connected.\ncause: ${e}`
+        `echo-back-connector connection(${connection.name}:${connection.endpoint}) is not connected.`,
+        e
       )
     }
   }

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,19 +31,22 @@ 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}`)
+          ConnectionManager.logger.error(
+            `[GraphQL error] Message: ${message}, Location: ${locations}, Path: ${path}`,
+            graphQLErrors
+          )
         })
 
       if (networkError) {
-        ConnectionManager.logger.error(`[Network error - ${networkError.statusCode}] ${networkError}`)
+        ConnectionManager.logger.error(`[Network error - ${networkError.statusCode}]`, networkError)
       }
     }
 
@@ -65,6 +64,10 @@ export class GraphqlConnector implements Connector {
       return forward(operation)
     })
 
+    const cache = new InMemoryCache({
+      addTypename: false
+    })
+
     ConnectionManager.addConnectionInstance(
       connection,
       new ApolloClient({
@@ -87,7 +90,7 @@ export class GraphqlConnector implements Connector {
   }
 
   async disconnect(connection: InputConnection) {
-    var client = ConnectionManager.getConnectionInstance(connection)
+    const client = ConnectionManager.getConnectionInstance(connection)
     client.stop()
     ConnectionManager.removeConnectionInstance(connection)
 

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

@@ -39,7 +39,8 @@ export class MqttConnector implements Connector {
       ConnectionManager.logger.info(`mqtt-connector connection(${connection.name}:${connection.endpoint}) is connected`)
     } catch (err) {
       ConnectionManager.logger.error(
-        `mqtt-connector connection(${connection.name}:${connection.endpoint}) is failed.\ncause: ${err}`
+        `mqtt-connector connection(${connection.name}:${connection.endpoint}) is failed.`,
+        err
       )
     }
   }

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

@@ -7,7 +7,7 @@ import { InputConnection } from '../../service/connection/connection-type'
 try {
   var Client = require('mssql')
 } catch (err) {
-  logger.error('mssql module loading failed')
+  logger.error('mssql module loading failed', err)
 }
 
 export class MssqlConnector implements Connector {
@@ -20,7 +20,7 @@ export class MssqlConnector implements Connector {
   async connect(connection: InputConnection) {
     const {
       endpoint,
-      params: { user, password, database, encrypt = 'Y' }
+      params: { user, password, database, encrypt = 'Y', trustServerCertificate }
     } = connection
 
     const [host, port = 1433] = endpoint.split(':')
@@ -33,9 +33,17 @@ export class MssqlConnector implements Connector {
       // client is pool
       user,
       password,
-      server: `${host}`,
-      database: `${database}`,
-      encrypt: `${encrypt === 'Y'}`
+      server: host,
+      database,
+      pool: {
+        max: 10,
+        min: 0,
+        idleTimeoutMillis: 30000
+      },
+      options: {
+        encrypt: encrypt === 'Y',
+        trustServerCertificate: trustServerCertificate === 'Y'
+      }
     })
 
     ConnectionManager.addConnectionInstance(connection, {
@@ -88,6 +96,14 @@ export class MssqlConnector implements Connector {
         property: {
           options: ['Y', 'N']
         }
+      },
+      {
+        type: 'select',
+        name: 'trustServerCertificate',
+        label: 'trust-server-certificate',
+        property: {
+          options: ['Y', 'N']
+        }
       }
     ]
   }

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,13 +154,13 @@ 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)
         },
         error: error => {
-          ConnectionManager.logger.error(`(${connection.name}:${connection.endpoint}) subscription error: ${error}`)
+          ConnectionManager.logger.error(`(${connection.name}:${connection.endpoint}) subscription error`, error)
         },
         complete: () => {
           ConnectionManager.logger.info(`(${connection.name}:${connection.endpoint}) subscription complete`)
@@ -185,18 +183,18 @@ export class OperatoConnector implements Connector {
     ConnectionManager.addConnectionInstance(connection, client)
 
     ConnectionManager.logger.info(
-      `graphql-connector connection(${connection.name}:${connection.endpoint}) is connected`
+      `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,7 +205,7 @@ 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}`)
     }
@@ -215,15 +213,13 @@ export class OperatoConnector implements Connector {
     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`
+        `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

@@ -7,7 +7,7 @@ import { InputConnection } from '../../service/connection/connection-type'
 try {
   var oracledb = require('oracledb')
 } catch (err) {
-  logger.error('oracledb module loading failed')
+  logger.error('oracledb module loading failed', err)
 }
 
 export class OracleConnector implements Connector {
@@ -71,7 +71,7 @@ export class OracleConnector implements Connector {
       poolAlias,
       enableStatistics
     })
-    
+
     ConnectionManager.addConnectionInstance(connection, {
       query: async (query, params) => {
         let dbConnection: any = {}
@@ -89,12 +89,10 @@ export class OracleConnector implements Connector {
             await this.recreatePool(connection)
           }
           throw e
-        }
-        finally {
+        } finally {
           await dbConnection.close()
         }
         return taskResult
-        
       },
       execute: async (procedure, params) => {
         let dbConnection: any = {}
@@ -105,7 +103,7 @@ export class OracleConnector implements Connector {
             ${procedure}
           END;`
           dbConnection = await oracledb.getConnection(poolAlias)
-          
+
           // console.log('\n************* stat after get ****************')
           // await oracledb.getPool(poolAlias).logStatistics()
 
@@ -131,8 +129,7 @@ export class OracleConnector implements Connector {
             await this.recreatePool(connection)
           }
           throw e
-        }
-        finally {
+        } finally {
           await dbConnection.close()
 
           // console.log('\n************* stat after close ****************')

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

@@ -7,7 +7,7 @@ import { InputConnection } from '../../service/connection/connection-type'
 try {
   var { Client } = require('pg')
 } catch (err) {
-  logger.error('postgresql module loading failed')
+  logger.error('postgresql module loading failed', err)
 }
 
 export class PostgresqlConnector implements Connector {
@@ -55,7 +55,8 @@ export class PostgresqlConnector implements Connector {
       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.\ncause: ${e}`
+        `PostgresSQL Database(${connection.name}:${database}) at ${endpoint} not connected.`,
+        e
       )
     }
   }

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/connector/socket-server.ts

@@ -40,7 +40,7 @@ export class SocketServer implements Connector {
           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)
+          logger.error(msg, ex)
           reject(ex)
         })
       })

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

@@ -6,11 +6,10 @@ 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')
+  logger.error('sqlite3 module loading failed', err)
 }
 
 export class SqliteConnector implements Connector {
@@ -29,9 +28,7 @@ export class SqliteConnector implements Connector {
 
     var database = new sqlite3.Database(endpoint, sqlite3.OPEN_READWRITE, err => {
       if (err) {
-        ConnectionManager.logger.error(
-          `SQLite Database(${connection.name}) at ${endpoint} not connected.\ncause: ${err}`
-        )
+        ConnectionManager.logger.error(`SQLite Database(${connection.name}) at ${endpoint} not connected.`, err)
         return
       }
 

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'
+export { Connector, Context, TaskHandler } from './types'