@gokiteam/goki-dev 0.2.0

package/src/protocols/mqtt/Server.js

@@ -0,0 +1,116 @@
+import net from 'net'
+import Moment from 'moment'
+import { Application } from '../../configs/Application.js'
+import { Logger } from '../../singletons/Logger.js'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import { MQTT_CLIENTS } from '../../db/Tables.js'
+import { Broker } from './Broker.js'
+
+class MqttServerClass {
+  constructor () {
+    this.server = null
+    this.isRunning = false
+  }
+
+  start () {
+    if (this.isRunning) {
+      Logger.log({
+        level: 'warn',
+        message: 'MQTT Server already running'
+      })
+      return
+    }
+
+    // Register storage collections
+    this.registerStorageCollections()
+
+    // Mark all previously connected clients as disconnected on server restart
+    this.cleanupStaleConnections()
+
+    // Initialize broker
+    const broker = Broker.initialize()
+
+    // Create TCP server
+    this.server = net.createServer(broker.handle)
+
+    // Handle server errors
+    this.server.on('error', (error) => {
+      Logger.log({
+        level: 'error',
+        message: 'MQTT Server error',
+        data: { error: error.message, stack: error.stack }
+      })
+    })
+
+    // Start listening
+    const port = Application.ports.mqtt
+    this.server.listen(port, () => {
+      this.isRunning = true
+      Logger.log({
+        level: 'info',
+        message: `MQTT Server started on port ${port}`,
+        data: { port, protocol: 'MQTT' }
+      })
+    })
+
+    return this.server
+  }
+
+  registerStorageCollections () {
+    // No-op for SQLite - tables created at DB initialization
+    Logger.log({
+      level: 'debug',
+      message: 'MQTT storage tables ready (SQLite)',
+      data: { tables: ['mqtt_clients', 'mqtt_messages', 'mqtt_subscriptions'] }
+    })
+  }
+
+  cleanupStaleConnections () {
+    try {
+      const staleClients = SqliteStore.find(MQTT_CLIENTS, { disconnectedAt: null })
+      if (staleClients.length > 0) {
+        const now = Moment().toISOString()
+        staleClients.forEach(client => {
+          SqliteStore.update(MQTT_CLIENTS, client.clientId, { disconnectedAt: now }, 'clientId')
+        })
+        Logger.log({
+          level: 'info',
+          message: 'Marked stale MQTT connections as disconnected',
+          data: { count: staleClients.length }
+        })
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to cleanup stale connections',
+        data: { error: error.message }
+      })
+    }
+  }
+
+  stop () {
+    if (!this.isRunning) {
+      Logger.log({
+        level: 'warn',
+        message: 'MQTT Server not running'
+      })
+      return
+    }
+
+    // Close broker
+    Broker.shutdown()
+
+    // Close server
+    if (this.server) {
+      this.server.close(() => {
+        this.isRunning = false
+        Logger.log({
+          level: 'info',
+          message: 'MQTT Server stopped'
+        })
+      })
+    }
+  }
+}
+
+export const MqttServer = new MqttServerClass()

package/src/runtime/FunctionRunner.js

@@ -0,0 +1,179 @@
+import { spawn } from 'child_process'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { Logger } from '../singletons/Logger.js'
+import { FunctionStatuses } from '../enums/FunctionStatuses.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..')
+const FRAMEWORK_BIN = path.join(PROJECT_ROOT, 'node_modules', '.bin', 'functions-framework')
+
+/**
+ * Manages a single Cloud Function's child process.
+ * Spawns functions-framework as a subprocess and monitors its lifecycle.
+ */
+export class FunctionRunner {
+  constructor (config) {
+    this.name = config.name
+    this.source = config.source
+    this.sourcePath = config.sourcePath
+    this.entryPoint = config.entryPoint
+    this.port = config.port
+    this.signatureType = config.signatureType || 'cloudevent'
+    this.env = config.env || {}
+    this.timeoutSeconds = config.timeoutSeconds || 60
+    this.process = null
+    this.status = FunctionStatuses.STOPPED
+    this.startedAt = null
+    this.onLog = null
+    this.onStatusChange = null
+  }
+
+  async start () {
+    if (this.status === FunctionStatuses.RUNNING) return
+    this.status = FunctionStatuses.STARTING
+    this.notifyStatusChange()
+    const args = [
+      `--target=${this.entryPoint}`,
+      `--source=${this.source}`,
+      `--port=${this.port}`,
+      `--signature-type=${this.signatureType}`
+    ]
+    const childEnv = { ...process.env, ...this.env }
+    try {
+      this.process = spawn(FRAMEWORK_BIN, args, {
+        cwd: this.sourcePath,
+        env: childEnv,
+        stdio: ['ignore', 'pipe', 'pipe']
+      })
+      this.process.stdout.on('data', (data) => {
+        if (this.onLog) this.onLog(this.name, 'stdout', data.toString())
+      })
+      this.process.stderr.on('data', (data) => {
+        if (this.onLog) this.onLog(this.name, 'stderr', data.toString())
+      })
+      this.process.on('exit', (code, signal) => {
+        const wasRunning = this.status === FunctionStatuses.RUNNING
+        this.status = code === 0 || signal === 'SIGTERM'
+          ? FunctionStatuses.STOPPED
+          : FunctionStatuses.ERROR
+        this.process = null
+        this.notifyStatusChange()
+        Logger.log({
+          level: wasRunning ? 'warn' : 'debug',
+          message: `Function process exited: ${this.name}`,
+          data: { code, signal, status: this.status }
+        })
+      })
+      this.process.on('error', (err) => {
+        this.status = FunctionStatuses.ERROR
+        this.process = null
+        this.notifyStatusChange()
+        Logger.log({
+          level: 'error',
+          message: `Function process error: ${this.name}`,
+          data: { error: err.message }
+        })
+      })
+      await this.waitForReady()
+      this.status = FunctionStatuses.RUNNING
+      this.startedAt = Date.now()
+      this.notifyStatusChange()
+      Logger.log({
+        level: 'info',
+        message: `Function started: ${this.name}`,
+        data: { port: this.port, entryPoint: this.entryPoint }
+      })
+    } catch (error) {
+      this.status = FunctionStatuses.ERROR
+      this.notifyStatusChange()
+      if (this.process) {
+        this.process.kill('SIGKILL')
+        this.process = null
+      }
+      throw error
+    }
+  }
+
+  async waitForReady () {
+    const maxWaitMs = 15000
+    const pollIntervalMs = 500
+    const startTime = Date.now()
+    while (Date.now() - startTime < maxWaitMs) {
+      try {
+        const response = await fetch(`http://localhost:${this.port}/`, {
+          method: 'GET',
+          signal: AbortSignal.timeout(2000)
+        })
+        if (response) return
+      } catch {
+        // Not ready yet
+      }
+      if (!this.process || this.process.exitCode !== null) {
+        throw new Error(`Function process exited before becoming ready: ${this.name}`)
+      }
+      await new Promise(resolve => setTimeout(resolve, pollIntervalMs))
+    }
+    throw new Error(`Function failed to become ready within ${maxWaitMs}ms: ${this.name}`)
+  }
+
+  async stop () {
+    if (!this.process) {
+      this.status = FunctionStatuses.STOPPED
+      return
+    }
+    return new Promise((resolve) => {
+      const killTimeout = setTimeout(() => {
+        if (this.process) {
+          this.process.kill('SIGKILL')
+        }
+      }, 5000)
+      this.process.once('exit', () => {
+        clearTimeout(killTimeout)
+        this.status = FunctionStatuses.STOPPED
+        this.process = null
+        this.notifyStatusChange()
+        resolve()
+      })
+      this.process.kill('SIGTERM')
+    })
+  }
+
+  async restart () {
+    await this.stop()
+    await this.start()
+  }
+
+  async healthCheck () {
+    if (!this.process || this.status !== FunctionStatuses.RUNNING) {
+      return { healthy: false, status: this.status }
+    }
+    try {
+      const response = await fetch(`http://localhost:${this.port}/`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(3000)
+      })
+      return { healthy: response.ok || response.status < 500, status: this.status }
+    } catch {
+      return { healthy: false, status: this.status }
+    }
+  }
+
+  getStatus () {
+    return {
+      name: this.name,
+      status: this.status,
+      port: this.port,
+      pid: this.process?.pid || null,
+      uptime: this.startedAt && this.status === FunctionStatuses.RUNNING
+        ? Date.now() - this.startedAt
+        : null
+    }
+  }
+
+  notifyStatusChange () {
+    if (this.onStatusChange) {
+      this.onStatusChange(this.name, this.status)
+    }
+  }
+}