@gokiteam/goki-dev 0.2.0

package/src/api/scheduler/Controllers.js

@@ -0,0 +1,27 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async startTick (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.startTick({ traceId })
+    ctx.reply(result)
+  },
+
+  async stopTick (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.stopTick({ traceId })
+    ctx.reply(result)
+  },
+
+  async getTickStatus (ctx) {
+    const { traceId } = ctx.state
+    const result = Logic.getTickStatus({ traceId })
+    ctx.reply(result)
+  },
+
+  async triggerTick (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.triggerTick({ traceId })
+    ctx.reply(result)
+  }
+}

package/src/api/scheduler/Logic.js

@@ -0,0 +1,49 @@
+import { TickService } from '../../singletons/TickService.js'
+
+export const Logic = {
+  async startTick (params) {
+    const { traceId } = params
+    const result = await TickService.start()
+    return {
+      ...result,
+      ...TickService.getStatus(),
+      traceId
+    }
+  },
+
+  stopTick (params) {
+    const { traceId } = params
+    const result = TickService.stop()
+    return {
+      ...result,
+      ...TickService.getStatus(),
+      traceId
+    }
+  },
+
+  getTickStatus (params) {
+    const { traceId } = params
+    return {
+      ...TickService.getStatus(),
+      traceId
+    }
+  },
+
+  async triggerTick (params) {
+    const { traceId } = params
+    try {
+      await TickService.publishTick()
+      return {
+        tickTime: new Date().toISOString(),
+        published: true,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  }
+}

package/src/api/scheduler/Router.js

@@ -0,0 +1,16 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+const v1 = new KoaRouter({ prefix: '/v1/scheduler' })
+
+v1.post('/tick/start', Controllers.startTick)
+v1.post('/tick/stop', Controllers.stopTick)
+v1.post('/tick/status', Controllers.getTickStatus)
+
+// Testing Helpers
+v1.post('/tick/trigger', Controllers.triggerTick)
+
+Router.use(v1.routes())
+
+export { Router }

package/src/api/services/Controllers.js

@@ -0,0 +1,26 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async list (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.list({ traceId })
+    ctx.reply(result)
+  },
+  async status (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.status({ traceId })
+    ctx.reply(result)
+  },
+  async restart (ctx) {
+    const { traceId } = ctx.state
+    const { serviceName } = ctx.request.body
+    const result = await Logic.restart({ serviceName, traceId })
+    ctx.reply(result)
+  },
+  async healthCheck (ctx) {
+    const { traceId } = ctx.state
+    const { healthEndpoint } = ctx.request.body
+    const result = await Logic.healthCheck({ healthEndpoint, traceId })
+    ctx.reply(result)
+  }
+}

package/src/api/services/Logic.js

@@ -0,0 +1,205 @@
+import { Application } from '../../configs/Application.js'
+import { MqttServer } from '../../protocols/mqtt/Server.js'
+import { FirestoreEmulator } from '../../emulation/firestore/Server.js'
+import { AppGatewayService } from '../../services/AppGatewayService.js'
+import { ServiceNames, ServiceDisplayNames, ServiceDescriptions, isValidServiceName } from '../../enums/ServiceNames.js'
+
+export const Logic = {
+  async list (params) {
+    const { traceId } = params
+    const { ports } = Application
+    const startTime = Application.runId
+    const currentTime = Date.now()
+    const uptime = currentTime - startTime
+
+    const services = [
+      {
+        name: ServiceNames.PUBSUB,
+        displayName: ServiceDisplayNames[ServiceNames.PUBSUB],
+        port: ports.pubsub,
+        status: 'running',
+        uptime,
+        description: ServiceDescriptions[ServiceNames.PUBSUB],
+        capabilities: {
+          canStart: false,
+          canStop: false,
+          canRestart: false
+        }
+      },
+      {
+        name: ServiceNames.MQTT,
+        displayName: ServiceDisplayNames[ServiceNames.MQTT],
+        port: ports.mqtt,
+        status: 'running',
+        uptime,
+        description: ServiceDescriptions[ServiceNames.MQTT],
+        capabilities: {
+          canStart: true,
+          canStop: true,
+          canRestart: true
+        }
+      },
+      {
+        name: ServiceNames.FIRESTORE,
+        displayName: ServiceDisplayNames[ServiceNames.FIRESTORE],
+        port: ports.firestore,
+        status: 'running',
+        uptime,
+        description: ServiceDescriptions[ServiceNames.FIRESTORE],
+        capabilities: {
+          canStart: true,
+          canStop: true,
+          canRestart: true
+        }
+      },
+      {
+        name: ServiceNames.WEBUI,
+        displayName: ServiceDisplayNames[ServiceNames.WEBUI],
+        port: ports.webUi,
+        status: 'running',
+        uptime,
+        description: ServiceDescriptions[ServiceNames.WEBUI],
+        capabilities: {
+          canStart: false,
+          canStop: false,
+          canRestart: false
+        }
+      },
+      {
+        name: ServiceNames.APP_GATEWAY,
+        displayName: ServiceDisplayNames[ServiceNames.APP_GATEWAY],
+        port: null,
+        status: AppGatewayService.isRunning ? 'running' : 'stopped',
+        uptime: AppGatewayService.startedAt ? currentTime - AppGatewayService.startedAt : null,
+        description: ServiceDescriptions[ServiceNames.APP_GATEWAY],
+        capabilities: {
+          canStart: true,
+          canStop: true,
+          canRestart: true
+        }
+      }
+    ]
+
+    return {
+      data: services,
+      traceId
+    }
+  },
+  async status (params) {
+    const { traceId } = params
+    const { ports } = Application
+    const uptimeMs = process.uptime() * 1000
+
+    const services = [
+      {
+        name: ServiceNames.PUBSUB,
+        displayName: ServiceDisplayNames[ServiceNames.PUBSUB],
+        status: 'running',
+        uptime: uptimeMs,
+        port: ports.pubsub
+      },
+      {
+        name: ServiceNames.MQTT,
+        displayName: ServiceDisplayNames[ServiceNames.MQTT],
+        status: MqttServer.isRunning ? 'running' : 'stopped',
+        uptime: MqttServer.isRunning ? uptimeMs : null,
+        port: ports.mqtt
+      },
+      {
+        name: ServiceNames.FIRESTORE,
+        displayName: ServiceDisplayNames[ServiceNames.FIRESTORE],
+        status: FirestoreEmulator.isRunning ? 'running' : 'stopped',
+        uptime: FirestoreEmulator.isRunning ? uptimeMs : null,
+        port: ports.firestore
+      },
+      {
+        name: ServiceNames.WEBUI,
+        displayName: ServiceDisplayNames[ServiceNames.WEBUI],
+        status: 'running',
+        uptime: uptimeMs,
+        port: ports.webUi
+      },
+      {
+        name: ServiceNames.APP_GATEWAY,
+        displayName: ServiceDisplayNames[ServiceNames.APP_GATEWAY],
+        status: AppGatewayService.isRunning ? 'running' : 'stopped',
+        uptime: AppGatewayService.startedAt ? Date.now() - AppGatewayService.startedAt : null,
+        port: null
+      }
+    ]
+
+    return {
+      data: services,
+      traceId
+    }
+  },
+  async restart (params) {
+    const { serviceName, traceId } = params
+
+    // Validate service name using enum
+    if (!isValidServiceName(serviceName)) {
+      return {
+        message: `Unknown service: ${serviceName}. Valid services: ${Object.values(ServiceNames).join(', ')}`,
+        traceId
+      }
+    }
+
+    let message = ''
+    switch (serviceName) {
+      case ServiceNames.MQTT:
+        MqttServer.stop()
+        await MqttServer.start()
+        message = `${ServiceDisplayNames[ServiceNames.MQTT]} restarted successfully`
+        break
+      case ServiceNames.FIRESTORE:
+        await FirestoreEmulator.stop()
+        await FirestoreEmulator.start()
+        message = `${ServiceDisplayNames[ServiceNames.FIRESTORE]} restarted successfully`
+        break
+      case ServiceNames.PUBSUB:
+        message = `${ServiceDisplayNames[ServiceNames.PUBSUB]} restart not supported (requires full server restart)`
+        break
+      case ServiceNames.WEBUI:
+        message = `${ServiceDisplayNames[ServiceNames.WEBUI]} restart not supported (requires full server restart)`
+        break
+      case ServiceNames.APP_GATEWAY:
+        await AppGatewayService.stop()
+        await AppGatewayService.start()
+        message = `${ServiceDisplayNames[ServiceNames.APP_GATEWAY]} restarted successfully`
+        break
+      default:
+        message = `Service ${serviceName} restart not implemented`
+    }
+    return {
+      message,
+      traceId
+    }
+  },
+  async healthCheck (params) {
+    const { healthEndpoint, traceId } = params
+    const startTime = Date.now()
+    try {
+      const response = await fetch(healthEndpoint, {
+        method: 'GET',
+        signal: AbortSignal.timeout(5000)
+      })
+      const responseTime = Date.now() - startTime
+      return {
+        healthy: response.ok,
+        statusCode: response.status,
+        responseTime,
+        error: null,
+        traceId
+      }
+    } catch (error) {
+      const responseTime = Date.now() - startTime
+      return {
+        healthy: false,
+        statusCode: null,
+        responseTime,
+        error: error.message,
+        traceId
+      }
+    }
+  }
+}

package/src/api/services/Router.js

@@ -0,0 +1,14 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+const v1 = new KoaRouter({ prefix: '/v1/services' })
+
+v1.post('/list', Controllers.list)
+v1.post('/status', Controllers.status)
+v1.post('/restart', Controllers.restart)
+v1.post('/health/check', Controllers.healthCheck)
+
+Router.use(v1.routes())
+
+export { Router }

package/src/api/services/Schemas.js

@@ -0,0 +1,66 @@
+import { Joi } from '@gokiteam/koa'
+
+export const Schemas = {
+  list: {
+    request: {
+      body: {}
+    },
+    responses: {
+      success: {
+        services: Joi.array().items(
+          Joi.object({
+            name: Joi.string().required(),
+            displayName: Joi.string().required(),
+            port: Joi.number().integer().required(),
+            description: Joi.string().required()
+          })
+        ).required()
+      }
+    }
+  },
+  status: {
+    request: {
+      body: {}
+    },
+    responses: {
+      success: {
+        services: Joi.array().items(
+          Joi.object({
+            name: Joi.string().required(),
+            displayName: Joi.string().required(),
+            status: Joi.string().valid('running', 'stopped', 'error').required(),
+            uptime: Joi.number().integer().min(0).allow(null).required(),
+            port: Joi.number().integer().required()
+          })
+        ).required()
+      }
+    }
+  },
+  restart: {
+    request: {
+      body: {
+        serviceName: Joi.string().valid('pubsub', 'mqtt', 'logging').required()
+      }
+    },
+    responses: {
+      success: {
+        message: Joi.string().required()
+      }
+    }
+  },
+  healthCheck: {
+    request: {
+      body: {
+        healthEndpoint: Joi.string().uri().required()
+      }
+    },
+    responses: {
+      success: {
+        healthy: Joi.boolean().required(),
+        statusCode: Joi.number().integer().allow(null),
+        responseTime: Joi.number().integer().allow(null),
+        error: Joi.string().allow(null)
+      }
+    }
+  }
+}

package/src/api/snapshots/Controllers.js

@@ -0,0 +1,37 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async createSnapshot (ctx) {
+    const { traceId } = ctx.state
+    const { services, metadata } = ctx.request.body
+    const result = await Logic.createSnapshot({ services, metadata, traceId })
+    ctx.reply(result)
+  },
+
+  async restoreSnapshot (ctx) {
+    const { traceId } = ctx.state
+    const { snapshotId, restartServices } = ctx.request.body
+    const result = await Logic.restoreSnapshot({ snapshotId, restartServices, traceId })
+    ctx.reply(result)
+  },
+
+  async listSnapshots (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.listSnapshots({ traceId })
+    ctx.reply(result)
+  },
+
+  async getSnapshotDetails (ctx) {
+    const { traceId } = ctx.state
+    const { snapshotId } = ctx.request.body
+    const result = await Logic.getSnapshotDetails({ snapshotId, traceId })
+    ctx.reply(result)
+  },
+
+  async deleteSnapshot (ctx) {
+    const { traceId } = ctx.state
+    const { snapshotId } = ctx.request.body
+    const result = await Logic.deleteSnapshot({ snapshotId, traceId })
+    ctx.reply(result)
+  }
+}