@gnar-engine/cli 1.0.0 → 1.0.2

package/bootstrap/services/control/src/controllers/http.controller.js

@@ -0,0 +1,228 @@
+import { commands } from '@gnar-engine/core';
+import { authorise } from '../policies/task.policy.js';
+
+
+/**
+ * HTTP controller
+ */
+export const httpController = {
+
+	/**
+	 * Schedule a task
+	 */
+	tasksSchedule: {
+		method: 'POST',
+		url: '/tasks/schedule',
+		preHandler: async (request, reply) => authorise.scheduleTaskByApi(request, reply),
+		handler: async (request, reply) => {
+
+			// params from request
+			const params = {
+				name: request.body.name,
+				payload: request.body.payload
+			};
+
+			// execute
+			const task = await commands.execute('scheduleTask', params);
+
+			// handle response
+			reply.code(200).send(
+				{ task: task }
+			);
+		},
+	},
+
+	/**
+	 * Execute task (not implemented)
+	 */
+	tasksExecute: {
+		method: 'POST',
+		url: '/tasks/execute',
+		preHandler: async (request, reply) => authorise.executeTaskByApi(request, reply),
+		handler: async (request, reply) => {
+
+			// handle response
+			reply.code(400).send(
+				{ message: 'Not implemented' }
+			);
+		},
+	},
+
+	/**
+	 * Execute task batch
+	 */
+	tasksExecuteBatch: {
+		method: 'POST',
+		url: '/tasks/execute-batch',
+		preHandler: async (request, reply) => authorise.executeTaskByApi(request, reply),
+		handler: async (request, reply) => {
+
+			// execute
+			const errors = await commands.execute('handleTaskBatch', request.body?.status);
+
+			if (errors && errors.length > 0) {
+				// handle response
+				reply.code(200).send(
+					{
+						message: 'Task batch run but had errors',
+						errors: errors
+					}
+				);
+				return;
+			}
+
+			// handle response
+			reply.code(200).send(
+				{ message: 'Task batch run with no errors' }
+			);
+		},
+	},
+
+	/**
+	 * Get tasks by status
+	 */
+	tasksGet: {
+		method: 'GET',
+		url: '/tasks/',
+		preHandler: async (request, reply) => authorise.executeTaskByApi(request, reply),
+		handler: async (request, reply) => {
+
+			const status = request.query.status || 'scheduled';
+
+			// execute
+			const tasks = await commands.execute('getTasksByStatus', status);
+
+			// handle response
+			reply.code(200).send(
+				{
+					status: status,
+					tasks: tasks
+				}
+			);
+		},
+	},
+
+	/**
+	 * Delete failed tasks
+	 */
+	tasksDeleteFailed: {
+		method: 'POST',
+		url: '/tasks/delete-failed',
+		preHandler: async (request, reply) => authorise.executeTaskByApi(request, reply),
+		handler: async (request, reply) => {
+
+			// execute
+			const numDeletedTasks = await commands.execute('deleteFailedTasks');
+
+			// handle response
+			reply.code(200).send(
+				{
+					message: 'Failed tasks deleted',
+					numDeletedTasks: numDeletedTasks
+				}
+			);
+		},
+	},
+
+	/**
+	 * Migrations
+	 */
+	runMigrations: {
+		method: 'POST',
+		url: '/control/migrations',
+		preHandler: async (request, reply) => authorise.runMigrationsByApi(request, reply),
+		handler: async (request, reply) => {
+
+			const params = {
+				service: request.body.service || null,
+				migration: request.body.migration || null
+			};
+
+			// execute
+			await commands.execute('runMigrations', params);
+
+			// handle response
+			reply.code(200).send(
+				{ message: 'Migrations triggered' }
+			);
+		},
+	},
+
+	/**
+	 * Seeders
+	 */
+	runSeeders: {
+		method: 'POST',
+		url: '/control/seeders',
+		preHandler: async (request, reply) => authorise.runSeedersByApi(request, reply),
+		handler: async (request, reply) => {
+
+			const params = {
+				service: request.body.service || null
+			};
+
+			// execute
+			await commands.execute('runSeeders', params);
+
+			// handle response
+			reply.code(200).send(
+				{ message: 'Seeders triggered' }
+			);
+		}
+	},
+
+	/**
+	 * Reset
+	 */
+	reset: {
+		method: 'POST',
+		url: '/control/reset',
+		preHandler: async (request, reply) => authorise.runResetByApi(request, reply),
+		handler: async (request, reply) => {
+
+			const params = {
+				service: request.body.service || null
+			};
+
+			// execute
+			await commands.execute('runReset', params);
+
+			// handle response
+			reply.code(200).send(
+				{ message: 'Reset triggered' }
+			);
+		}
+	},
+
+	/**
+	 * Health check
+	 */
+	healthCheck: {
+		method: 'GET',
+		url: '/control/health',
+		handler: async (request, reply) => {
+
+			// execute
+			await commands.execute('runHealthcheck');
+
+			// handle response
+			reply.code(200).send(
+				{ message: 'health check passed!' }
+			);
+		}
+	},
+
+	/**
+	 * ECS health check
+	 */
+	ecsHealthCheck: {
+		method: 'GET',
+		url: '/control/',
+		handler: async (request, reply) => {
+			reply.code(200).send(
+				{ message: 'Server is up' }
+			);
+		}
+	},
+
+};

package/bootstrap/services/control/src/controllers/message.controller.js

@@ -0,0 +1,40 @@
+import { commands } from '@gnar-engine/core';
+
+
+/**
+ * Message Controller: handlers for incoming service messages
+ */
+export const messageHandlers = {
+
+    registerService: async (payload) => {
+        const service = await commands.execute('registerService', {
+            service: payload.data.service,
+        });
+
+        return { service };
+    },
+
+    getServices: async (payload) => {
+        const services = await commands.execute('getServices', payload.data);
+        
+        return { services };
+    },
+
+    scheduleTask: async (payload) => {
+        const task = await commands.execute('scheduleTask', payload.data);
+        
+        return { task };
+    },
+
+    cancelTasks: async (payload) => {
+        const tasks = await commands.execute('cancelTasks', payload.data);
+        
+        return { tasks };
+    },
+
+    getManifests: async (payload) => {
+        const manifests = await commands.execute('getManifests', payload.data);
+        
+        return { manifests };
+    }
+}

package/bootstrap/services/control/src/db/migrations/01-init.js

@@ -0,0 +1,50 @@
+import { logger, db } from '@gnar-engine/core';
+
+/**
+ * Up
+ */
+export const up = async () => {
+    await initDatabaseTables();
+}
+
+/**
+ * Down
+ */
+export const down = async () => {
+    await dropDatabaseTables();
+}
+
+/**
+ * Create all tables
+ */
+export const initDatabaseTables = async () => {
+
+    // Migrations table
+    logger.info("Creating migrations table");
+    const createMigrationsTableQuery = `
+        CREATE TABLE migrations (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            name VARCHAR(255) NOT NULL UNIQUE,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )`;
+    await db.query(createMigrationsTableQuery);
+
+    // Seeders table
+    logger.info("Creating seeders table");
+    const createSeedersTableQuery = `
+        CREATE TABLE seeders (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            name VARCHAR(255) NOT NULL UNIQUE,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )`;
+    await db.query(createSeedersTableQuery);
+}
+
+/**
+ * Drop all tables
+ */
+export const dropDatabaseTables = async () => {
+    logger.info('Dropping tables');
+    await db.query('DROP TABLE IF EXISTS migrations');
+    await db.query('DROP TABLE IF EXISTS seeders');
+}

package/bootstrap/services/control/src/db/migrations/02-control-service-init.js

@@ -0,0 +1,60 @@
+import { logger, db } from '@gnar-engine/core';
+
+/**
+ * Up
+ */
+export const up = async () => {
+    await initDatabaseTables();
+}
+
+/**
+ * Down
+ */
+export const down = async () => {
+    await dropDatabaseTables();
+}
+
+/**
+ * Create all tables
+ */
+export const initDatabaseTables = async () => {
+
+    // Tasks table
+    logger.info('Creating tasks table');
+    const createTasksTableQuery = `
+        CREATE TABLE tasks (
+            id CHAR(36) PRIMARY KEY,
+            name VARCHAR(255) NOT NULL,
+            payload TEXT,
+            status ENUM('scheduled', 'queued', 'completed', 'failed', 'cancelled') DEFAULT 'scheduled',
+            scheduled TIMESTAMP,
+            recurring_interval ENUM('daily', 'weekly', 'monthly', 'yearly', 'none') DEFAULT 'none',
+            recurring_interval_count INT DEFAULT 0,
+            handler_service_name VARCHAR(255) NOT NULL,
+            handler_name VARCHAR(255) NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+        )`;
+    await db.query(createTasksTableQuery);
+
+    // Service registry table
+    logger.info('Creating service registry table');
+    const createServiceRegistryTableQuery = `
+        CREATE TABLE service_registry (
+            id CHAR(36) PRIMARY KEY,
+            name VARCHAR(255) NOT NULL,
+            manifest JSON,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+        )`;
+    await db.query(createServiceRegistryTableQuery);
+}
+
+/**
+ * Drop all tables
+ */
+export const dropDatabaseTables = async () => {
+    logger.info('Dropping tables');
+    await db.query('DROP TABLE IF EXISTS tasks');
+    await db.query('DROP TABLE IF EXISTS service_registry');
+}

package/bootstrap/services/control/src/db/migrations/03-alter-tasks.js

@@ -0,0 +1,29 @@
+import { logger, db } from '@gnar-engine/core';
+
+/**
+ * Up
+ */
+export const up = async () => {
+    await alertTaskTable();
+}
+
+/**
+ * Down
+ */
+export const down = async () => {
+
+}
+
+/**
+ * Add new columns to task table
+ */
+export const alertTaskTable = async () => {
+    const alterTasksTableQuery = `
+        ALTER TABLE tasks
+        MODIFY COLUMN recurring_interval ENUM('hourly', 'daily', 'weekly', 'monthly', 'yearly', 'none') DEFAULT 'none',
+        ADD COLUMN reschedule_centrally_on_success BOOLEAN DEFAULT FALSE,
+        ADD COLUMN reschedule_centrally_on_failure BOOLEAN DEFAULT FALSE,
+        ADD COLUMN idempotency_key VARCHAR(255) DEFAULT NULL
+    `;
+    await db.query(alterTasksTableQuery);
+}

package/bootstrap/services/control/src/policies/task.policy.js

@@ -0,0 +1,53 @@
+
+export const authorise = {
+
+    /**
+     * Authorise update product
+     */
+    scheduleTaskByApi: async (request, reply) => {
+        // only service admins can schedule tasks via the API
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise execute task
+     */
+    executeTaskByApi: async (request, reply) => {
+        // only service admins can execute tasks via the API
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise run migrations
+     */
+    runMigrationsByApi: async (request, reply) => {
+        // only service admins can run migrations via the API
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise run seeders
+     */
+    runSeedersByApi: async (request, reply) => {
+        // only service admins can run seeders via the API
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise run reset
+     */
+    runResetByApi: async (request, reply) => {
+        // only service admins can run reset via the API
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    }
+}

package/bootstrap/services/control/src/schema/control.schema.js

@@ -0,0 +1,42 @@
+import { schema } from '@gnar-engine/core';
+
+// Task schema
+const taskSchema = {
+    schemaName: 'controlService.taskSchema',
+    schema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string' },
+            payload: { type: 'object' },
+            status: { type: 'string', enum: ['scheduled'] },
+            scheduled: { type: 'string', format: 'mysql-date' },
+            recurringInterval: { type: 'string', enum: ['hourly', 'daily', 'weekly', 'monthly', 'yearly'] },
+            recurringIntervalCount: { type: 'number' },
+            handlerServiceName: { type: 'string' },
+            handlerName: { type: 'string' },
+            rescheduleCentrallyOnSuccess: { type: 'boolean' },
+            rescheduleCentrallyOnFailure: { type: 'boolean' },
+            idempotencyKey: { type: 'string' }
+        },
+        required: ['name', 'payload', 'scheduled', 'handlerServiceName', 'handlerName'],
+        additionalProperties: false
+    }
+};
+
+// Service schema
+const serviceSchema = {
+    schemaName: 'controlService.serviceSchema',
+    schema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string' },
+            manifest: { type: 'object' }
+        },
+        required: ['name'],
+        additionalProperties: false
+    }
+};
+
+// Compile schemas
+export const validateTask = schema.compile(taskSchema);
+export const validateService = schema.compile(serviceSchema);

package/bootstrap/services/control/src/services/registry.service.js

@@ -0,0 +1,83 @@
+import { db, utils, logger } from '@gnar-engine/core';
+
+
+/**
+ * Registry Service
+ */
+export const registry = {
+
+    // register service
+    registerService: async ({name, manifest}) => {
+        try {
+            const [result] = await db.execute(
+                'INSERT INTO `service_registry` (`id`, `name`, `manifest`) VALUES (?, ?, ?)',
+                [utils.uuid(), name, manifest]
+            );
+
+            return result.insertId;
+        } catch (error) {
+            logger.error("Error registering service: " + error);
+            throw error;
+        }
+    },
+
+    updateService: async ({name, manifest}) => {
+        try {
+            const [result] = await db.execute(
+                'UPDATE `service_registry` SET `manifest` = ?, `updated_at` = CURRENT_TIMESTAMP WHERE `name` = ?',
+                [manifest, name]
+            );
+            return result.affectedRows;
+        } catch (error) {
+            logger.error("Error updating service: " + error);
+            throw error;
+        }
+    },
+
+    // get services
+    getServices: async () => {
+        try {
+            const [result] = await db.execute(
+                'SELECT name FROM `service_registry`'
+            );
+
+            return result;
+        } catch (error) {
+            logger.error("Error getting services: " + error);
+            throw error;
+        }
+    },
+
+    /**
+     * Get services with manifests
+     */
+    getServicesWithManifests: async () => {
+        try {
+            const [result] = await db.execute(
+                'SELECT * FROM `service_registry`'
+            );
+
+            return result;
+        } catch (error) {
+            logger.error("Error getting services: " + error);
+            throw error;
+        }
+    },
+
+
+    /**
+     * Get manifests
+     */
+    getManifests: async () => {
+        try {
+            const [result] = await db.execute(
+                'SELECT manifest FROM `service_registry`'
+            );
+
+            return result;
+        } catch (error) {
+            logger.error("Error getting manifests: " + error);
+            throw error;
+        }
+    }
+}

package/bootstrap/services/control/src/services/reset.service.js

@@ -0,0 +1,28 @@
+import { logger } from '@gnar-engine/core';
+
+
+/**
+ * Registry Service
+ */
+export const reset = {
+
+    // drop MYSQL databases
+    dropMysqlDatabases: async () => {
+        try {
+            throw new Error("Not implemented");
+        } catch (error) {
+            logger.error("Error resetting MYSQL: " + error);
+            throw error;
+        }
+    },
+
+    // drop all mongodb collections
+    dropMongoCollections: async () => {
+        try {
+            throw new Error("Not implemented");
+        } catch (error) {
+            logger.error("Error resetting MYSQL: " + error);
+            throw error;
+        }
+    }
+}