@things-factory/integration-base 8.0.39 → 8.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "8.0.39",
+  "version": "8.0.40",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -44,5 +44,5 @@
     "readline": "^1.3.0",
     "ses": "^1.5.0"
   },
-  "gitHead": "f5e1a4c04bceec2d731a46f1ef88976839d04dac"
+  "gitHead": "6f97ca5dc8aab9acaeebbd3caace0c76bab2676d"
 }

package/server/engine/task/mqtt-publish.ts

@@ -1,13 +1,13 @@
 import { access } from '@things-factory/utils'
-import { TaskRegistry } from '../task-registry'
-import { ConnectionManager } from '../connection-manager'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
+import { TaskRegistry } from '../task-registry.js'
+import { ConnectionManager } from '../connection-manager.js'
+import { InputStep } from '../../service/step/step-type.js'
+import { Context } from '../types.js'
 
 async function MqttPublish(step: InputStep, { logger, data, domain }: Context) {
   var {
     connection: connectionName,
-    params: { topic, accessor }
+    params: { topic, accessor, dataFormat = 'json' }
   } = step
 
   const { client } = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
@@ -19,7 +19,14 @@ async function MqttPublish(step: InputStep, { logger, data, domain }: Context) {
     throw Error(`topic and accessor should be defined: : topic - '${topic}', accessor - '${accessor}'`)
   }
 
-  var message = JSON.stringify(access(accessor, data))
+  var message = access(accessor, data)
+
+  if (dataFormat === 'text') {
+    message = String(message)
+  } else {
+    message = JSON.stringify(message)
+  }
+
   await client.publish(topic, message)
 
   return {
@@ -37,6 +44,23 @@ MqttPublish.parameterSpec = [
     type: 'scenario-step-input',
     name: 'accessor',
     label: 'accessor'
+  },
+  {
+    type: 'select',
+    label: 'data-format',
+    name: 'dataFormat',
+    property: {
+      options: [
+        {
+          display: 'Plain Text',
+          value: 'text'
+        },
+        {
+          display: 'JSON',
+          value: 'json'
+        }
+      ]
+    }
   }
 ]
 

package/server/engine/task/mqtt-subscribe.ts

@@ -1,31 +1,128 @@
 import mqtt from 'async-mqtt'
 
-import { TaskRegistry } from '../task-registry'
-import { ConnectionManager } from '../connection-manager'
-import { sleep } from '@things-factory/utils'
-import { InputStep } from '../../service/step/step-type'
-import { Context } from '../types'
+import { TaskRegistry } from '../task-registry.js'
+import { ConnectionManager } from '../connection-manager.js'
+import { InputStep } from '../../service/step/step-type.js'
+import { Context } from '../types.js'
 
 function convertDataFormat(data, format) {
   if (format == 'json') {
-    return JSON.parse(data)
+    try {
+      return JSON.parse(data)
+    } catch (e) {
+      console.error('JSON 파싱 오류:', e.message)
+      return data.toString()
+    }
   } else {
     return data.toString()
   }
 }
 
-async function MqttSubscribe(step: InputStep, context: Context) {
+// MQTT 연결을 위한 브로커 관리 클래스
+class MqttBrokerManager {
+  private static brokers: Record<
+    string,
+    {
+      client: mqtt.AsyncMqttClient
+      topics: Set<string>
+      messageHandlers: Map<string, (topic: string, message: Buffer) => void>
+    }
+  > = {}
+
+  // 브로커 연결 (또는 기존 연결 반환)
+  static async getBroker(uri: string, options?: mqtt.IClientOptions) {
+    const brokerKey = `${uri}_${JSON.stringify(options || {})}`
+
+    if (!this.brokers[brokerKey]) {
+      const client = await mqtt.connectAsync(uri, options)
+
+      this.brokers[brokerKey] = {
+        client,
+        topics: new Set<string>(),
+        messageHandlers: new Map()
+      }
+
+      // 메시지 수신 핸들러
+      client.on('message', (topic, message) => {
+        // 해당 토픽에 등록된 핸들러가 있으면 호출
+        this.brokers[brokerKey].messageHandlers.forEach((handler, handlerId) => {
+          if (handlerId.startsWith(`${topic}:`)) {
+            handler(topic, message)
+          }
+        })
+      })
+    }
+
+    return this.brokers[brokerKey]
+  }
+
+  // 토픽 구독 등록
+  static async subscribe(brokerKey: string, topic: string) {
+    const broker = this.brokers[brokerKey]
+    if (!broker) {
+      throw new Error(`브로커가 연결되지 않음: ${brokerKey}`)
+    }
+
+    // 새 토픽인 경우 구독
+    if (!broker.topics.has(topic)) {
+      await broker.client.subscribe(topic)
+      broker.topics.add(topic)
+    }
+  }
+
+  // 메시지 핸들러 등록
+  static registerMessageHandler(
+    brokerKey: string,
+    topic: string,
+    handlerId: string,
+    handler: (topic: string, message: Buffer) => void
+  ) {
+    const broker = this.brokers[brokerKey]
+    if (!broker) {
+      throw new Error(`브로커가 연결되지 않음: ${brokerKey}`)
+    }
+
+    // 핸들러 ID는 topic:handlerId 형식으로 저장
+    const fullHandlerId = `${topic}:${handlerId}`
+    broker.messageHandlers.set(fullHandlerId, handler)
+
+    return () => {
+      // 핸들러 제거 함수 반환
+      broker.messageHandlers.delete(fullHandlerId)
+    }
+  }
+
+  // 연결 종료
+  static async disconnect(brokerKey: string) {
+    const broker = this.brokers[brokerKey]
+    if (broker) {
+      await broker.client.end()
+      delete this.brokers[brokerKey]
+    }
+  }
+
+  // 브로커 키 생성 유틸리티
+  static getBrokerKey(uri: string, options?: any) {
+    return `${uri}_${JSON.stringify(options || {})}`
+  }
+}
+
+interface MqttContext extends Context {
+  __mqtt_connections?: Set<string>
+  __mqtt_handlers?: Map<string, () => void>
+  __mqtt_resolvers?: Map<string, (result: any) => void>
+}
+
+async function MqttSubscribe(step: InputStep, context: MqttContext) {
   const {
     connection: connectionName,
     params: { topic, dataFormat },
-    name
+    name: stepName
   } = step
 
-  const { domain, logger, closures, __mqtt_subscriber } = context
-  if (!__mqtt_subscriber) {
-    context.__mqtt_subscriber = {}
-  }
+  const { domain, logger, closures } = context
 
+  // MQTT 브로커 접속 정보 가져오기
   const {
     connection: {
       endpoint: uri,
@@ -34,78 +131,133 @@ async function MqttSubscribe(step: InputStep, context: Context) {
   } = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
 
   if (!topic) {
-    throw Error(`topic is not found for ${connectionName}`)
+    throw Error(`토픽이 지정되지 않음: ${connectionName}`)
   }
 
-  /*
-   * 1. subscriber list에서 subscriber를 찾는다. 없으면, 생성한다.
-   * 2. client.once(...)로 메시지를 취한다.
-   *
-   * TODO 동일 브로커의 다중 subscribe 태스크에 대해서 완벽한 지원을 해야한다.
-   * - 현재는 여러 태스크가 동일 topic을 subscribe 하는 경우에 정상동작하지 않을 것이다.
-   */
-  if (!context.__mqtt_subscriber[name]) {
-    try {
-      var broker = null
-      if (user && password) {
-        broker = await mqtt.connectAsync(uri, { username: user, password: password })
-      } else {
-        broker = await mqtt.connectAsync(uri)
-      }
+  // 브로커 연결 키 생성
+  const connectionOptions = user && password ? { username: user, password } : undefined
+  const brokerKey = MqttBrokerManager.getBrokerKey(uri, connectionOptions)
 
-      logger.info(`mqtt-connector connection(${connectionName}:${uri}) is connected`)
+  // 구독자 ID 생성 (도메인, 연결명, 토픽, 스텝명 조합)
+  const subscriberId = `${domain}_${connectionName}_${topic}_${stepName}`
 
-      await broker.subscribe(topic)
-      logger.info(`success subscribing topic '${topic}'`)
+  try {
+    // 브로커 연결 (또는 기존 연결 가져오기)
+    await MqttBrokerManager.getBroker(uri, connectionOptions)
+    logger.info(`MQTT 연결 완료: ${connectionName}:${uri}`)
 
-      var TOPIC
-      var MESSAGE
+    // 토픽 구독 등록
+    await MqttBrokerManager.subscribe(brokerKey, topic)
+    logger.info(`토픽 구독 완료: ${topic}`)
 
-      context.__mqtt_subscriber[name] = async () => {
-        while (!MESSAGE) {
-          await sleep(100)
-        }
+    // 리졸버 저장소 초기화
+    if (!context.__mqtt_resolvers) {
+      context.__mqtt_resolvers = new Map()
+    }
 
-        var topic = TOPIC
-        var message = MESSAGE
+    // 클로저에 연결 종료 함수 등록
+    if (!context.__mqtt_connections) {
+      context.__mqtt_connections = new Set()
+    }
+
+    if (!context.__mqtt_handlers) {
+      context.__mqtt_handlers = new Map()
+    }
+
+    // 연결 추적 (중복 종료 방지)
+    if (!context.__mqtt_connections.has(brokerKey)) {
+      context.__mqtt_connections.add(brokerKey)
+
+      // 연결 종료 함수 등록
+      closures.push(async () => {
+        try {
+          // 핸들러 모두 제거
+          if (context.__mqtt_handlers) {
+            context.__mqtt_handlers.forEach(removeHandler => {
+              removeHandler()
+            })
+            context.__mqtt_handlers.clear()
+          }
 
-        TOPIC = null
-        MESSAGE = null
+          // 대기 중인 모든 Promise 해결
+          if (context.__mqtt_resolvers) {
+            context.__mqtt_resolvers.forEach(resolver => {
+              resolver({ data: null, terminated: true })
+            })
+            context.__mqtt_resolvers.clear()
+          }
 
-        return {
-          topic,
-          message
+          // 연결 종료
+          await MqttBrokerManager.disconnect(brokerKey)
+          logger.info(`MQTT 연결 종료: ${connectionName}:${uri}`)
+        } catch (e) {
+          logger.error(`MQTT 연결 종료 오류: ${e.message}`)
         }
+      })
+    }
+
+    // Promise로 메시지 수신 대기
+    return new Promise(resolve => {
+      // 이 태스크의 resolver 저장
+      if (context.__mqtt_resolvers) {
+        context.__mqtt_resolvers.set(subscriberId, resolve)
       }
 
-      broker.on('message', async (messageTopic, message) => {
-        if (topic !== messageTopic) {
-          return
+      // 이미 등록된 핸들러가 있으면 제거
+      if (context.__mqtt_handlers?.has(subscriberId)) {
+        const removeHandler = context.__mqtt_handlers.get(subscriberId)
+        if (removeHandler) {
+          removeHandler()
         }
+      }
 
-        TOPIC = topic
-        MESSAGE = convertDataFormat(message, dataFormat)
+      // 새로운 메시지 핸들러 등록
+      const removeHandler = MqttBrokerManager.registerMessageHandler(
+        brokerKey,
+        topic,
+        subscriberId,
+        (messageTopic, message) => {
+          try {
+            // 메시지 변환
+            const convertedMessage = convertDataFormat(message, dataFormat)
 
-        // logger.info(`mqtt-subscribe :\n'${message.toString()}'`)
-      })
+            // resolver 가져오기 및 삭제
+            if (context.__mqtt_resolvers?.has(subscriberId)) {
+              const resolver = context.__mqtt_resolvers.get(subscriberId)
+              context.__mqtt_resolvers.delete(subscriberId)
 
-      closures.push(async () => {
-        try {
-          broker && (await broker.end())
-          logger.info(`mqtt-connector connection(${connectionName}:${uri}) is disconnected`)
-        } catch (e) {
-          logger.error(e)
+              // 이 태스크에 대한 핸들러 제거 (한 번만 실행되도록)
+              if (context.__mqtt_handlers?.has(subscriberId)) {
+                const removeHandler = context.__mqtt_handlers.get(subscriberId)
+                if (removeHandler) {
+                  removeHandler()
+                }
+                context.__mqtt_handlers.delete(subscriberId)
+              }
+
+              // Promise 해결
+              if (resolver) {
+                resolver({
+                  data: convertedMessage
+                })
+              }
+            }
+          } catch (error) {
+            logger.error(`메시지 처리 오류: ${error.message}`)
+          }
         }
-      })
-    } catch (e) {
-      logger.error(e)
-    }
-  }
+      )
 
-  var { message } = await context.__mqtt_subscriber[name]()
+      // 핸들러 제거 함수 저장
+      if (context.__mqtt_handlers) {
+        context.__mqtt_handlers.set(subscriberId, removeHandler)
+      }
 
-  return {
-    data: message
+      logger.info(`MQTT 메시지 대기 중: ${topic}`)
+    })
+  } catch (e) {
+    logger.error(`MQTT 구독 오류: ${e.message}`)
+    throw e
   }
 }