@gokiteam/goki-dev 0.2.0

package/src/services/AppGatewayService.js

@@ -0,0 +1,582 @@
+import { v4 as uuid } from 'uuid'
+import crypto from 'crypto'
+import {
+  BridgeScanResultRecord,
+  BridgeScanStatusNotification,
+  DcpV2DeviceNotificationPacket,
+  DcpV2DeviceResponseForServerPacket,
+  DcpV2OnlineServerRequestPacket,
+  ErrorCode,
+  ForwardPacketRequest,
+  ForwardPacketResponse,
+  ForwardPacketV2Request,
+  ForwardPacketV2Response,
+  Interface,
+  NotificationType,
+  Operation,
+  Protocol
+} from '@portalteam/protocols'
+import { Application } from '../configs/Application.js'
+import { Logger } from '../singletons/Logger.js'
+import { Broker } from '../protocols/mqtt/Broker.js'
+import { PublishMessages } from '../emulation/pubsub/Logic.js'
+import { GatewayState } from '../enums/GatewayState.js'
+
+class AppGatewayServiceClass {
+  constructor () {
+    this.state = GatewayState.STOPPED
+    this.gatewayDevice = null
+    this.masterSecret = null
+    this.scanInterval = null
+    this.startedAt = null
+    this.retryTimer = null
+    this.dependencyHealth = {
+      deviceNative: { reachable: false, lastChecked: null, error: null },
+      deviceSimulator: { reachable: false, lastChecked: null, error: null }
+    }
+  }
+
+  get isRunning () {
+    return this.state === GatewayState.RUNNING
+  }
+
+  // --- Auto-start and dependency health ---
+
+  async autoStart () {
+    const { autoStart } = Application.appGateway
+    if (!autoStart) {
+      Logger.log({
+        level: 'info',
+        message: 'Gateway auto-start is disabled (APP_GATEWAY_AUTO_START=false)'
+      })
+      return
+    }
+    Logger.log({
+      level: 'info',
+      message: 'Gateway auto-start initiated'
+    })
+    const health = await this.checkDependencyHealth()
+    if (health.allHealthy) {
+      const result = await this.start()
+      if (!result.success) {
+        Logger.log({
+          level: 'warn',
+          message: 'Gateway immediate start failed, entering retry loop',
+          data: { error: result.message }
+        })
+        this.startRetryLoop()
+      }
+    } else {
+      this.startRetryLoop()
+    }
+  }
+
+  async checkDependencyHealth () {
+    const { deviceNativeUrl, deviceSimulatorUrl } = Application.appGateway
+    const check = async (url, name) => {
+      try {
+        const controller = new AbortController()
+        const timeout = setTimeout(() => controller.abort(), 3000)
+        const response = await fetch(`${url}/v1/health/liveness`, {
+          method: 'GET',
+          signal: controller.signal
+        })
+        clearTimeout(timeout)
+        const reachable = response.ok
+        this.dependencyHealth[name] = {
+          reachable,
+          lastChecked: Date.now(),
+          error: reachable ? null : `HTTP ${response.status}`
+        }
+        return reachable
+      } catch (error) {
+        this.dependencyHealth[name] = {
+          reachable: false,
+          lastChecked: Date.now(),
+          error: error.name === 'AbortError' ? 'Timeout' : error.message
+        }
+        return false
+      }
+    }
+    const [nativeOk, simulatorOk] = await Promise.all([
+      check(deviceNativeUrl, 'deviceNative'),
+      check(deviceSimulatorUrl, 'deviceSimulator')
+    ])
+    return { allHealthy: nativeOk && simulatorOk, deviceNative: nativeOk, deviceSimulator: simulatorOk }
+  }
+
+  startRetryLoop () {
+    if (this.retryTimer) return
+    const { retryIntervalSeconds } = Application.appGateway
+    this.state = GatewayState.WAITING_FOR_DEPENDENCIES
+    Logger.log({
+      level: 'info',
+      message: 'Gateway waiting for dependencies',
+      data: {
+        retryIntervalSeconds,
+        deviceNativeUrl: Application.appGateway.deviceNativeUrl,
+        deviceSimulatorUrl: Application.appGateway.deviceSimulatorUrl
+      }
+    })
+    this.retryTimer = setInterval(async () => {
+      const health = await this.checkDependencyHealth()
+      if (health.allHealthy) {
+        Logger.log({
+          level: 'info',
+          message: 'All dependencies available, starting gateway'
+        })
+        this.stopRetryLoop()
+        const result = await this.start()
+        if (!result.success) {
+          Logger.log({
+            level: 'warn',
+            message: 'Gateway start failed after dependencies ready, will retry',
+            data: { error: result.message }
+          })
+          this.startRetryLoop()
+        }
+      } else {
+        Logger.log({
+          level: 'debug',
+          message: 'Dependencies not ready yet',
+          data: { deviceNative: health.deviceNative, deviceSimulator: health.deviceSimulator }
+        })
+      }
+    }, retryIntervalSeconds * 1000)
+  }
+
+  stopRetryLoop () {
+    if (this.retryTimer) {
+      clearInterval(this.retryTimer)
+      this.retryTimer = null
+    }
+  }
+
+  // --- Lifecycle methods ---
+
+  async start () {
+    if (this.state === GatewayState.RUNNING) {
+      Logger.log({
+        level: 'warn',
+        message: 'App Gateway is already running'
+      })
+      return { success: false, message: 'App Gateway is already running' }
+    }
+    this.stopRetryLoop()
+    this.state = GatewayState.STARTING
+    const { propertyId, deviceNativeUrl, deviceSimulatorUrl } = Application.appGateway
+    try {
+      Logger.log({
+        level: 'info',
+        message: 'Starting App Gateway service...',
+        data: { propertyId, deviceNativeUrl, deviceSimulatorUrl }
+      })
+      await this.ensureGatewayExists()
+      this.subscribeToRequestTopic()
+      this.startScanInterval()
+      this.state = GatewayState.RUNNING
+      this.startedAt = Date.now()
+      Logger.log({
+        level: 'info',
+        message: 'App Gateway service started successfully',
+        data: {
+          gatewayId: this.gatewayDevice?.id,
+          macAddress: this.gatewayDevice?.macAddress
+        }
+      })
+      return {
+        success: true,
+        message: 'App Gateway started',
+        gateway: this.gatewayDevice
+      }
+    } catch (error) {
+      this.state = GatewayState.ERROR
+      Logger.log({
+        level: 'error',
+        message: 'Failed to start App Gateway service',
+        data: { error: error.message, stack: error.stack }
+      })
+      return { success: false, message: error.message }
+    }
+  }
+
+  async stop () {
+    if (this.state === GatewayState.STOPPED) {
+      return { success: false, message: 'App Gateway is not running' }
+    }
+    Logger.log({
+      level: 'info',
+      message: 'Stopping App Gateway service...'
+    })
+    this.stopRetryLoop()
+    if (this.scanInterval) {
+      clearInterval(this.scanInterval)
+      this.scanInterval = null
+    }
+    this.state = GatewayState.STOPPED
+    this.startedAt = null
+    Logger.log({
+      level: 'info',
+      message: 'App Gateway service stopped'
+    })
+    return { success: true, message: 'App Gateway stopped' }
+  }
+
+  getStatus () {
+    const { propertyId, deviceNativeUrl, deviceSimulatorUrl, scanIntervalSeconds, autoStart } = Application.appGateway
+    return {
+      state: this.state,
+      isRunning: this.isRunning,
+      startedAt: this.startedAt,
+      uptime: this.startedAt ? Date.now() - this.startedAt : null,
+      gateway: this.gatewayDevice
+        ? {
+            id: this.gatewayDevice.id,
+            macAddress: this.gatewayDevice.macAddress,
+            propertyId: this.gatewayDevice.propertyId
+          }
+        : null,
+      dependencies: this.dependencyHealth,
+      config: {
+        propertyId,
+        deviceNativeUrl,
+        deviceSimulatorUrl,
+        scanIntervalSeconds,
+        autoStart
+      }
+    }
+  }
+
+  async triggerScan () {
+    if (!this.isRunning) {
+      return { success: false, message: 'App Gateway is not running' }
+    }
+    try {
+      await this.publishScanNotification()
+      return { success: true, message: 'Scan notification published' }
+    } catch (error) {
+      return { success: false, message: error.message }
+    }
+  }
+
+  // --- Gateway registration ---
+
+  async ensureGatewayExists () {
+    const { propertyId, deviceNativeUrl } = Application.appGateway
+    const macAddress = this.generateMacAddress()
+    const masterSecret = crypto.randomBytes(16).toString('base64')
+    try {
+      const createResponse = await fetch(`${deviceNativeUrl}/v1/devices/createAppGateway`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          propertyId,
+          macAddress,
+          masterSecret,
+          supportedProtocols: [Protocol.dcpV2],
+          supportedOperations: [Operation.forwardPacket, Operation.forwardPacketV2],
+          supportedInterfaces: [Interface.ble],
+          supportedNotifications: [NotificationType.bridgeScanStatus]
+        })
+      })
+      const createResult = await createResponse.json()
+      if (createResult.success && createResult.data?.device) {
+        this.gatewayDevice = createResult.data.device
+        this.masterSecret = masterSecret
+        Logger.log({
+          level: 'info',
+          message: 'Created app gateway',
+          data: { gatewayId: this.gatewayDevice.id, macAddress: this.gatewayDevice.macAddress }
+        })
+        return
+      }
+      throw new Error(createResult.message || 'Failed to create app gateway')
+    } catch (error) {
+      if (error.message.includes('Failed to create')) {
+        throw error
+      }
+      throw new Error(`Failed to connect to device-native at ${deviceNativeUrl}: ${error.message}`)
+    }
+  }
+
+  generateMacAddress () {
+    const bytes = crypto.randomBytes(6)
+    bytes[0] = (bytes[0] | 0x02) & 0xfe
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(':')
+  }
+
+  // --- MQTT subscription and message handling ---
+
+  subscribeToRequestTopic () {
+    if (!this.gatewayDevice) {
+      throw new Error('Gateway device not initialized')
+    }
+    const broker = Broker.getInstance()
+    const requestTopic = `rq/4/${this.gatewayDevice.id}`
+    broker.subscribe(
+      requestTopic,
+      (packet, cb) => {
+        this.handleRequest(packet.topic, packet.payload).catch(error => {
+          Logger.log({
+            level: 'error',
+            message: 'Error handling gateway request',
+            data: { error: error.message }
+          })
+        })
+        if (cb) cb()
+      },
+      () => {
+        Logger.log({
+          level: 'info',
+          message: `Subscribed to request topic: ${requestTopic}`
+        })
+      }
+    )
+  }
+
+  // --- Scan notifications ---
+
+  startScanInterval () {
+    const { scanIntervalSeconds } = Application.appGateway
+    this.publishScanNotification().catch(error => {
+      Logger.log({
+        level: 'error',
+        message: 'Error publishing initial scan notification',
+        data: { error: error.message }
+      })
+    })
+    this.scanInterval = setInterval(async () => {
+      try {
+        await this.publishScanNotification()
+      } catch (error) {
+        Logger.log({
+          level: 'error',
+          message: 'Error publishing scan notification',
+          data: { error: error.message }
+        })
+      }
+    }, scanIntervalSeconds * 1000)
+  }
+
+  async publishScanNotification () {
+    if (!this.gatewayDevice || !this.masterSecret) {
+      return
+    }
+    const { propertyId, deviceSimulatorUrl } = Application.appGateway
+    let scanResults = []
+    try {
+      const response = await fetch(`${deviceSimulatorUrl}/v1/devices/scanProperty`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ propertyId })
+      })
+      const result = await response.json()
+      if (result.success && result.data?.scanResults) {
+        scanResults = result.data.scanResults
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'debug',
+        message: 'Failed to scan property',
+        data: { error: error.message }
+      })
+      return
+    }
+    if (!scanResults.length) {
+      Logger.log({
+        level: 'debug',
+        message: 'No devices found during scan'
+      })
+      return
+    }
+    const notification = new BridgeScanStatusNotification({
+      scanResultRecords: scanResults.map(({ rssi, macAddress, bcpPacket }) => {
+        const bcpPacketBuffer = Buffer.from(bcpPacket, 'base64')
+        return new BridgeScanResultRecord({
+          macAddress,
+          rssi: rssi || -50,
+          bcpPacket: bcpPacketBuffer,
+          timeSinceScannedSeconds: 10
+        })
+      }),
+      recordCount: scanResults.length,
+      rssi: -50
+    })
+    const transport = new DcpV2DeviceNotificationPacket({
+      notificationPayload: notification.serialize(),
+      notificationType: NotificationType.bridgeScanStatus
+    })
+    const key = Buffer.from(this.masterSecret, 'base64')
+    const encryptedPacket = transport.serialize({ key })
+    const notificationTopic = `nf/4/${this.gatewayDevice.id}`
+    const broker = Broker.getInstance()
+    broker.publish({
+      topic: notificationTopic,
+      payload: encryptedPacket,
+      qos: 1,
+      retain: true
+    })
+    await this.forwardToPubSub(notificationTopic, encryptedPacket)
+    Logger.log({
+      level: 'debug',
+      message: 'Published scan notification',
+      data: { deviceCount: scanResults.length, topic: notificationTopic }
+    })
+  }
+
+  // --- Request handling ---
+
+  async handleRequest (topic, payload) {
+    if (!this.gatewayDevice || !this.masterSecret) {
+      return
+    }
+    const { propertyId, deviceSimulatorUrl } = Application.appGateway
+    const key = Buffer.from(this.masterSecret, 'base64')
+    const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload)
+    let operationId, operationPayload, requestId
+    try {
+      const deserialized = DcpV2OnlineServerRequestPacket.deserialize({ buffer, keys: [key] })
+      operationId = deserialized.operationId
+      operationPayload = deserialized.operationPayload
+      requestId = deserialized.requestId
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to deserialize request packet',
+        data: { error: error.message }
+      })
+      return
+    }
+    const responseTopic = `rs/4/${this.gatewayDevice.id}`
+    let transportPacketRaw
+    if (operationId === Operation.forwardPacket) {
+      const { destinationDeviceMacAddress, packet } = ForwardPacketRequest.deserialize({ buffer: operationPayload })
+      try {
+        const response = await fetch(`${deviceSimulatorUrl}/v1/devices/processRequest`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            propertyId,
+            macAddress: destinationDeviceMacAddress,
+            requestPacket: packet.toString('base64')
+          })
+        })
+        const result = await response.json()
+        if (result.success && result.data?.responsePacket) {
+          const forwardPacketResponse = new ForwardPacketResponse({
+            packet: Buffer.from(result.data.responsePacket, 'base64')
+          })
+          transportPacketRaw = new DcpV2DeviceResponseForServerPacket({
+            requestId,
+            responsePayload: forwardPacketResponse.serialize()
+          })
+        } else {
+          transportPacketRaw = new DcpV2DeviceResponseForServerPacket({
+            requestId,
+            errorCode: ErrorCode.cannotFindDevice
+          })
+        }
+      } catch (error) {
+        Logger.log({
+          level: 'error',
+          message: 'Failed to process forward packet request',
+          data: { error: error.message, macAddress: destinationDeviceMacAddress }
+        })
+        transportPacketRaw = new DcpV2DeviceResponseForServerPacket({
+          requestId,
+          errorCode: ErrorCode.cannotFindDevice
+        })
+      }
+    } else if (operationId === Operation.forwardPacketV2) {
+      const { destinationDeviceMacAddress, packet } = ForwardPacketV2Request.deserialize({ buffer: operationPayload })
+      try {
+        const response = await fetch(`${deviceSimulatorUrl}/v1/devices/processRequest`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            propertyId,
+            macAddress: destinationDeviceMacAddress,
+            requestPacket: packet.toString('base64')
+          })
+        })
+        const result = await response.json()
+        if (result.success && result.data?.responsePacket) {
+          const forwardPacketResponse = new ForwardPacketV2Response({
+            packet: Buffer.from(result.data.responsePacket, 'base64'),
+            remainingAttemptCount: 2
+          })
+          transportPacketRaw = new DcpV2DeviceResponseForServerPacket({
+            requestId,
+            responsePayload: forwardPacketResponse.serialize()
+          })
+        } else {
+          transportPacketRaw = new DcpV2DeviceResponseForServerPacket({
+            requestId,
+            errorCode: ErrorCode.cannotFindDevice
+          })
+        }
+      } catch (error) {
+        Logger.log({
+          level: 'error',
+          message: 'Failed to process forward packet v2 request',
+          data: { error: error.message, macAddress: destinationDeviceMacAddress }
+        })
+        transportPacketRaw = new DcpV2DeviceResponseForServerPacket({
+          requestId,
+          errorCode: ErrorCode.cannotFindDevice
+        })
+      }
+    } else {
+      Logger.log({
+        level: 'warn',
+        message: 'Unhandled operation type',
+        data: { operationId }
+      })
+      return
+    }
+    const encryptedResponse = transportPacketRaw.serializeWithAes128Gcm({ key })
+    const broker = Broker.getInstance()
+    broker.publish({
+      topic: responseTopic,
+      payload: encryptedResponse,
+      qos: 1,
+      retain: true
+    })
+    await this.forwardToPubSub(responseTopic, encryptedResponse)
+    Logger.log({
+      level: 'debug',
+      message: 'Published response',
+      data: { topic: responseTopic, operationId }
+    })
+  }
+
+  // --- Pub/Sub forwarding ---
+
+  async forwardToPubSub (topicName, payload) {
+    const { pubsub } = Application
+    const messageData = {
+      clientId: this.gatewayDevice?.id || 'app-gateway',
+      topicName,
+      packet: payload.toString('base64'),
+      receivedAtMilliseconds: Date.now()
+    }
+    try {
+      PublishMessages({
+        projectId: pubsub.projectId,
+        topicId: 'mqttMessageReceived',
+        messages: [{
+          data: Buffer.from(JSON.stringify(messageData)).toString('base64'),
+          attributes: { traceId: uuid() }
+        }]
+      })
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to forward to Pub/Sub',
+        data: { error: error.message, topicName }
+      })
+    }
+  }
+}
+
+export const AppGatewayService = new AppGatewayServiceClass()