Feature/ping services

.env.example

@@ -14,3 +14,6 @@ DB_URL=mongodb://mongodb:27017
 
 # Workspaces config filename
 CONFIG_FILE=config.yml
+
+# Cron schedule for ping services
+PING_SCHEDULE="* * * * *"

package.json

@@ -25,12 +25,16 @@
     "@types/express": "^4.17.8",
     "@types/jest": "^26.0.15",
     "@types/node": "^14.14.2",
+    "@types/node-cron": "^2.0.3",
+    "@types/ping": "^0.2.0",
     "@types/ws": "^7.2.7",
     "ctproto": "^0.0.7",
     "dotenv": "^8.2.0",
     "express": "^4.17.1",
     "mongoose": "^5.10.11",
     "nanoid": "^3.1.18",
+    "node-cron": "^2.0.3",
+    "ping": "^0.4.0",
     "typescript": "^4.1.2",
     "ws": "^7.3.1",
     "yaml": "^1.10.0"

src/config/index.ts

@@ -27,4 +27,8 @@ export default class Config {
    * Workspaces config-file path
    */
   public static workspacesConfigPath: string = process.env.CONFIG_FILE || '';
+  /**
+   * Cron schedule for setting pinging interval
+   */
+  public static pingSchedule: string = process.env.PING_SCHEDULE || '*/30 * * * * *';
 }

src/controllers/statuses.ts

@@ -0,0 +1,108 @@
+import ping from 'ping';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental,@typescript-eslint/no-unused-vars
+import app from './../app';
+import WorkspacesService from './../services/workspace';
+import ServerProjectsStatuses, { ProjectStatus } from '../types/serverProjectsStatuses';
+import Workspace from './../types/workspace';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-unused-vars-experimental
+import Client from 'ctproto/build/src/server/client';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-unused-vars-experimental
+import { DevopsToolboxAuthData } from '../types/api/responses/authorize';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-unused-vars-experimental
+import { ApiOutgoingMessage, ApiResponse } from '../types';
+import Server from '../services/server';
+import { NginxPayload } from '../types/servicePayload';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-unused-vars-experimental
+
+/**
+ * Statuses controller to work with updating/checking/sending statuses of servers' statuses for each workspace
+ */
+export default class StatusesController {
+  /**
+   * Update statuses and send to logged users
+   */
+  public static async updateStatuses(): Promise<void> {
+    const workspaces: Workspace[] | null = await WorkspacesService.find();
+
+    /**
+     * If workspaces exist,then updating statuses for them
+     */
+    if (workspaces) {
+      for (const workspace of workspaces) {
+        /**
+         * For each server of workspace update statuses
+         */
+        for (const s of workspace.servers) {
+          for (const service of s.services) {
+            /**
+             * If type of service is nginx, server's projects are pinged
+             */
+            if (service.type === 'nginx') {
+              const projectsStatuses = await this.pingProjects(service.payload as NginxPayload[]);
+              const serverProjectsStatuses: ServerProjectsStatuses = {
+                projectsStatuses,
+                serverToken: s.token,
+              } as ServerProjectsStatuses;
+
+              await Server.updateServicesStatuses(serverProjectsStatuses);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Project availability check
+   *
+   * @param serverProject - array of workspace server's projects
+   */
+  public static async checkProjectAvailability(serverProject: string): Promise<ProjectStatus> {
+    if (serverProject === '') {
+      return {
+        host: 'Unnamed host',
+        isOnline: false,
+      };
+    } else {
+      const pingServer = await ping.promise.probe(serverProject);
+
+      return {
+        host: serverProject,
+        isOnline: pingServer.alive,
+      };
+    }
+  }
+
+  /**
+   * Ping projects of some server
+   *
+   * @param payload - list of project of payload of some service of some server
+   */
+  public static async pingProjects(payload: NginxPayload[]): Promise<ProjectStatus[]> {
+    const projectsStatuses:ProjectStatus[] = [];
+
+    for (const payloadElement of payload) {
+      const projectStatus = await StatusesController.checkProjectAvailability(payloadElement.serverName);
+
+      projectsStatuses.push(projectStatus);
+    }
+
+    return projectsStatuses;
+  }
+
+  /**
+   * Send statuses to clients
+   *
+   * @param statuses - array of statuses of all client services
+   * @param user - user
+   */
+  // public static sendStatuses(statuses: ServerProjectsStatuses[], user: Client<DevopsToolboxAuthData, ApiResponse, ApiOutgoingMessage>): void {
+  //   if (typeof user.authData.userToken === 'string') {
+  //     app.context.transport
+  //       .clients
+  //       .find((client) => client.authData.userToken === user.authData.userToken)
+  //       .send('statuses-updated', { statuses });
+  //   }
+  // }
+}

src/database/models/serverServicesStatuses.ts

@@ -0,0 +1,36 @@
+import mongoose from '..';
+import ServerProjectsStatuses from '../../types/serverProjectsStatuses';
+
+/**
+ * Project status Schema
+ */
+const serverProjectsStatusesSchema: mongoose.Schema = new mongoose.Schema({
+  /**
+   * Workspace server's token
+   */
+  serverToken: {
+    type: String,
+    required: true,
+  },
+  /**
+   * Workspace server's projects' names and statuses
+   */
+  projectsStatuses: [ {
+    /**
+     * Host name
+     */
+    host: {
+      type: String,
+      required: true,
+    },
+    /**
+     * host status
+     */
+    isOnline: {
+      type: Boolean,
+      required: true,
+    },
+  } ],
+});
+
+export default mongoose.model<ServerProjectsStatuses>('server_projects_statuses', serverProjectsStatusesSchema);

src/database/models/workspace.ts

@@ -19,6 +19,7 @@ const workspaceSchema: mongoose.Schema = new mongoose.Schema({
     type: String,
     required: true,
   },
+
   /**
    * Workspace servers
    */

src/index.ts

@@ -2,9 +2,11 @@
 /// <reference path="./types/app.d.ts" />
 import { CTProtoServer } from 'ctproto';
 import app from './app';
+import cron from 'node-cron';
 import Config from './config';
 import { WorkspacesController, ApiRequest, ApiResponse, ApiOutgoingMessage } from './types';
 import WorkspacesService from './services/workspace';
+import StatusesController from './controllers/statuses';
 import { AuthorizeMessagePayload } from './types/api/requests/authorize';
 import { DevopsToolboxAuthData } from './types/api/responses/authorize';
 
@@ -16,14 +18,12 @@ app.listen(Config.httpPort, Config.host, () => {
  * Initialize CTProto server for API
  */
 const transport = new CTProtoServer<AuthorizeMessagePayload, DevopsToolboxAuthData, ApiRequest, ApiResponse, ApiOutgoingMessage>({
-  host: Config.host,
   port: Config.wsPort,
   async onAuth(authRequestPayload: AuthorizeMessagePayload): Promise<DevopsToolboxAuthData> {
     /**
      * Connected client's authorization token
      */
     const authToken = authRequestPayload.token.toString();
-
     /**
      * Connected client's workspaces list
      */
@@ -63,3 +63,14 @@ const transport = new CTProtoServer<AuthorizeMessagePayload, DevopsToolboxAuthDa
  * @example req.app.locals.transport
  */
 app.context = { transport };
+
+/**
+ * Ping availability of connected user's services
+ */
+cron.schedule(Config.pingSchedule, () => {
+  StatusesController.updateStatuses()
+    .then()
+    .catch(e => {
+      console.log(e);
+    });
+});

src/services/server.ts

@@ -0,0 +1,43 @@
+import mongoose from '../database';
+import IServerProjectsStatuses from '../types/serverProjectsStatuses';
+import ServerProjectsStatuses from '../database/models/serverServicesStatuses';
+
+/**
+ * Server of workspace with token,services and projects
+ */
+export default class Server {
+  /**
+   * Add new server
+   *
+   * @param server - new server
+   */
+  public static async add(server: IServerProjectsStatuses): Promise<IServerProjectsStatuses | null> {
+    const newServer = new ServerProjectsStatuses(server);
+
+    return newServer.save();
+  }
+
+  /**
+   * Update of server projects' statuses in DB
+   *
+   * @param serverProjectsStatuses - server projects' statuses and server token
+   */
+  public static async updateServicesStatuses(serverProjectsStatuses: IServerProjectsStatuses): Promise<mongoose.Document> {
+    const server = await ServerProjectsStatuses.findOne({ serverToken: serverProjectsStatuses.serverToken });
+
+    if (!server) {
+      await this.add(serverProjectsStatuses);
+    }
+
+    return ServerProjectsStatuses.updateOne({
+      serverToken: serverProjectsStatuses.serverToken,
+    }, {
+      $set: {
+        projectsStatuses: serverProjectsStatuses.projectsStatuses,
+      },
+
+    }, {
+      new: true,
+    });
+  }
+}

src/services/workspace.ts

@@ -1,6 +1,7 @@
 import mongoose from '../database';
 import Workspace from '../database/models/workspace';
 import { Workspace as IWorkspace, Service } from '../types';
+import ServicePayload from '../types/servicePayload';
 
 /**
  * Workspace service
@@ -15,6 +16,15 @@ export default class WorkspacesService {
     return Workspace.find(workspaceOptions);
   }
 
+  /**
+   * Find one workspace with options
+   *
+   * @param workspaceOptions - Workspace options for looking for documents
+   */
+  public static async findOne(workspaceOptions: mongoose.FilterQuery<typeof Workspace> = {}): Promise<IWorkspace | null> {
+    return Workspace.findOne(workspaceOptions);
+  }
+
   /**
    * Add new workspace
    *
@@ -32,7 +42,7 @@ export default class WorkspacesService {
    * @param token - Server token
    * @param actualServices - Actual services
    */
-  public static async updateServices(token: string | undefined, actualServices: Service[]): Promise<IWorkspace | null> {
+  public static async updateServices(token: string | undefined, actualServices: Service<ServicePayload>[]): Promise<IWorkspace | null> {
     return Workspace.findOneAndUpdate({ 'servers.token': token }, {
       $set: {
         'servers.$.services': actualServices,

src/types/api/index.ts

@@ -3,6 +3,7 @@ import Authorize from './requests/authorize';
 import AuthorizeResponse from './responses/authorize';
 import GetWorkspacesResponse from './responses/getWorkspaces';
 import WorkspaceUpdatedMessage from './outgoing/workspaceUpdated';
+import StatusesUpdatedMessage from './outgoing/statusesUpdated';
 
 /**
  * This file uses Discriminating Unions types for our API
@@ -31,4 +32,5 @@ export type ApiResponse =
  */
 export type ApiOutgoingMessage =
   | WorkspaceUpdatedMessage
+  | StatusesUpdatedMessage
 ;

src/types/api/outgoing/statusesUpdated.ts

@@ -0,0 +1,19 @@
+import { NewMessage } from 'ctproto/types';
+import ServerProjectsStatuses from '../../serverProjectsStatuses';
+
+/**
+ * Data about the updated statuses
+ */
+interface StatusesUpdatedPayload {
+  /**
+   * The updated workspace
+   */
+  projectsStatuses: ServerProjectsStatuses;
+}
+
+/**
+ * Describes the outgoing message that will be sent when statuses of services will be updated
+ */
+export default interface StatusesUpdatedMessage extends NewMessage<StatusesUpdatedPayload> {
+  type: 'statuses-updated';
+}

src/types/server.ts

@@ -1,5 +1,6 @@
 import Service from './service';
 import SSHConnectionInfo from './SSHConnectionInfo';
+import ServicePayload from './servicePayload';
 
 /**
  * Interface for server
@@ -24,5 +25,5 @@ export default interface Server {
   /**
    * List of services running on the server
    */
-  services: Service[];
+  services: Service<ServicePayload>[];
 }

src/types/serverProjectsStatuses.ts

@@ -0,0 +1,28 @@
+import mongoose from 'mongoose';
+
+/**
+ * Project status of the server
+ */
+export interface ProjectStatus {
+  /**
+   * Name of host
+   */
+  host: string;
+  /**
+   * State of host (online/offline)
+   */
+  isOnline: boolean;
+}
+/**
+ * Status of service in workspace
+ */
+export default interface ServerProjectsStatuses extends mongoose.Document {
+  /**
+   * Server's (containing the services) id
+   */
+  serverToken: string;
+  /**
+   * Projects with their statuses of the server
+   */
+  projectsStatuses: ProjectStatus[];
+}