0z2i6v3u5t 1.0.0

package/src/initializers/servers.ts

@@ -0,0 +1,134 @@
+import * as path from "path";
+import { api, config, log, utils, Initializer, Server } from "../index";
+import { PluginConfig } from "../classes/config";
+import { safeGlobSync } from "../modules/utils/safeGlob";
+
+export interface ServersApi {
+  servers: {
+    [key: string]: Server;
+  };
+}
+
+/**
+ * Manages the servers in this Actionhero instance.
+ */
+export class Servers extends Initializer {
+  constructor() {
+    super();
+    this.name = "servers";
+    this.loadPriority = 599;
+    this.startPriority = 900;
+    this.stopPriority = 100;
+  }
+
+  async initialize() {
+    api.servers = {
+      servers: {},
+    };
+
+    const serverFolders = [path.resolve(path.join(__dirname, "..", "servers"))];
+
+    config.general.paths.server.forEach((p: string) => {
+      p = path.resolve(p);
+      if (serverFolders.indexOf(p) < 0) {
+        serverFolders.push(p);
+      }
+    });
+
+    let files: string[] = [];
+
+    for (const i in serverFolders) {
+      const p = serverFolders[i];
+      files = files.concat(safeGlobSync(path.join(p, "**", "**/*(*.js|*.ts)")));
+    }
+
+    for (const [_, plugin] of Object.entries(config.plugins as PluginConfig)) {
+      if (plugin.servers !== false) {
+        const pluginPath: string = path.normalize(plugin.path);
+
+        // old style at the root of the project
+        files = files.concat(
+          safeGlobSync(path.join(pluginPath, "servers", "**", "*.js")),
+        );
+
+        files = files.concat(
+          safeGlobSync(path.join(pluginPath, "dist", "servers", "**", "*.js")),
+        );
+      }
+    }
+
+    files = utils.ensureNoTsHeaderOrSpecFiles(files);
+
+    let server: Server;
+
+    for (const j in files) {
+      const filename = files[j];
+      const ExportedClasses = await import(filename);
+
+      const exportLen = Object.keys(ExportedClasses).length;
+      // we have named exports
+      if (exportLen) {
+        if (exportLen > 1) {
+          throw new Error(
+            `server file ${filename} exports more than one server`,
+          );
+        }
+
+        server = new ExportedClasses[Object.keys(ExportedClasses)[0]]();
+      } else {
+        // there is one default export
+        server = new ExportedClasses();
+      }
+
+      server.config = config[server.type]; // for shorthand access
+      if (server.config && server.config.enabled === true) {
+        await server.initialize();
+
+        if (api.servers.servers[server.type]) {
+          log(
+            `an existing server with the same type \`${server.type}\` will be overridden by the file ${filename}`,
+            "crit",
+          );
+        }
+
+        api.servers.servers[server.type] = server;
+        log(`Initialized server: ${server.type}`, "debug");
+      }
+    }
+  }
+
+  async start() {
+    for (const serverName of Object.keys(api.servers.servers)) {
+      const bindIp = config[serverName]?.bindIP?.toString();
+      const port = config[serverName]?.port?.toString();
+
+      const server = api.servers.servers[serverName];
+      if (server && server.config.enabled === true) {
+        const message = `Starting server: \`${serverName}\` ${
+          bindIp
+            ? `@ ${serverName === "web" ? "http://" : ""}${bindIp}${
+                port ? `:${port}` : ""
+              }`
+            : ""
+        }`;
+        log(message, "notice");
+        await server.start();
+        log(`Server started: ${serverName}`, "debug");
+      }
+    }
+  }
+
+  async stop() {
+    const serverNames = Object.keys(api.servers.servers);
+    for (const i in serverNames) {
+      const serverName = serverNames[i];
+      const server = api.servers.servers[serverName];
+      if ((server && server.config.enabled === true) || !server) {
+        log(`Stopping server: ${serverName}`, "notice");
+        await server.stop();
+        server.removeAllListeners();
+        log(`Server stopped: ${serverName}`, "debug");
+      }
+    }
+  }
+}

package/src/initializers/specHelper.ts

@@ -0,0 +1,195 @@
+import { EventEmitter } from "stream";
+import * as uuid from "uuid";
+import { ActionProcessor } from "../classes/actionProcessor";
+import { connectionVerbs } from "../classes/connection";
+import {
+  api,
+  config,
+  log,
+  env,
+  Initializer,
+  Server,
+  Connection,
+} from "../index";
+import { SpecHelperConnection } from "../modules/specHelper";
+
+export interface SpecHelperApi {
+  returnMetadata?: boolean;
+  // Server?: Server;
+  Server?: any;
+  Connection?: any;
+}
+
+/**
+ * A special "mock" server which enables you to test actions and tasks in a simple way.  Only available in the TEST environment.
+ */
+export class SpecHelper extends Initializer {
+  enabled: boolean;
+
+  constructor() {
+    super();
+    this.name = "specHelper";
+    this.loadPriority = 900;
+    this.startPriority = 901;
+    this.enabled = false;
+  }
+
+  async initialize() {
+    if (env === "test") this.enabled = true;
+    if (!this.enabled) return;
+
+    class TestServer extends Server {
+      constructor() {
+        super();
+
+        this.type = "testServer";
+        this.attributes = {
+          canChat: true,
+          logConnections: false,
+          logExits: false,
+          sendWelcomeMessage: true,
+          verbs: connectionVerbs,
+        };
+      }
+
+      async initialize() {}
+
+      async start() {
+        log("loading the testServer", "info");
+        this.on("connection", (connection) => {
+          this.handleConnection(connection);
+        });
+        this.on("actionComplete", (data) => {
+          this.actionComplete(data);
+        });
+      }
+
+      async stop() {}
+
+      async sendMessage(
+        connection: SpecHelperConnection,
+        message: any,
+        messageId: string | number,
+      ) {
+        process.nextTick(() => {
+          connection.messages.push(message);
+          if (typeof connection.actionCallbacks[messageId] === "function") {
+            connection.actionCallbacks[messageId](message, connection);
+            delete connection.actionCallbacks[messageId];
+          }
+        });
+      }
+
+      async sendFile(
+        connection: Connection,
+        error: NodeJS.ErrnoException,
+        fileStream: EventEmitter,
+        mime: string,
+        length: number,
+      ) {
+        let content = "";
+        const messageId = connection.messageId;
+        const response = {
+          content: null as string,
+          mime: mime,
+          length: length,
+          error: undefined as Error,
+        };
+
+        if (error) {
+          response.error = error;
+        }
+
+        try {
+          if (!error) {
+            fileStream.on("data", (d) => (content += d));
+            fileStream.on("end", () => {
+              response.content = content;
+              this.sendMessage(connection, response, messageId);
+            });
+          } else {
+            this.sendMessage(connection, response, messageId);
+          }
+        } catch (e) {
+          this.log(e, "warning");
+          this.sendMessage(connection, response, messageId);
+        }
+      }
+
+      handleConnection(connection: SpecHelperConnection) {
+        connection.messages = [];
+        connection.actionCallbacks = {};
+      }
+
+      async actionComplete(data: ActionProcessor<any>) {
+        data.response.error;
+        if (typeof data.response === "string" || Array.isArray(data.response)) {
+          // nothing to do...
+        } else {
+          if (data.response.error) {
+            data.response.error =
+              await config.errors.serializers.servers.specHelper(
+                data.response.error,
+              );
+          }
+
+          if (api.specHelper.returnMetadata) {
+            data.response.messageId = data.messageId;
+
+            data.response.serverInformation = {
+              serverName: config.general.serverName,
+              apiVersion: config.general.apiVersion,
+            };
+
+            data.response.requesterInformation = {
+              id: data.connection.id,
+              remoteIP: data.connection.remoteIP,
+              receivedParams: {},
+            };
+
+            for (const k in data.params) {
+              data.response.requesterInformation.receivedParams[k] =
+                data.params[k];
+            }
+          }
+        }
+
+        if (data.toRender === true) {
+          this.sendMessage(data.connection, data.response, data.messageId);
+        }
+      }
+    }
+
+    api.specHelper = {
+      returnMetadata: true,
+      Server: TestServer,
+    };
+
+    /**
+     * A special connection usable in tests.  Create via `await api.specHelper.Connection.createAsync()`
+     */
+    api.specHelper.Connection = class {
+      static async createAsync() {
+        const id = uuid.v4();
+
+        await api.servers.servers.testServer.buildConnection({
+          id: id,
+          fingerprint: id,
+          rawConnection: {},
+          remoteAddress: "testServer",
+          remotePort: 0,
+        });
+        return api.connections.connections[id];
+      }
+    };
+  }
+
+  async start() {
+    if (!this.enabled) return;
+
+    const server = new api.specHelper.Server();
+    server.config = { enabled: true };
+    await server.start(api);
+    api.servers.servers.testServer = server;
+  }
+}

package/src/initializers/staticFile.ts

@@ -0,0 +1,253 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as Mime from "mime";
+import { api, config, log, Initializer } from "../index";
+import { Connection } from "./../classes/connection";
+import { PluginConfig } from "../classes/config";
+
+export interface StaticFileApi {
+  searchLocations: Array<string>;
+  get?: StaticFileInitializer["get"];
+  sendFile?: StaticFileInitializer["sendFile"];
+  searchPath?: StaticFileInitializer["searchPath"];
+  checkExistence?: StaticFileInitializer["checkExistence"];
+  sendFileNotFound?: StaticFileInitializer["sendFileNotFound"];
+  logRequest?: StaticFileInitializer["logRequest"];
+  fileLogger?: StaticFileInitializer["fileLogger"];
+}
+
+/**
+ * Contains helpers for returning flies to connections.
+ */
+export class StaticFileInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "staticFile";
+    this.loadPriority = 510;
+  }
+
+  /**
+   * For a connection with `connection.params.file` set, return a file if we can find it, or a not-found message.
+   * `searchLocations` will be checked in the following order: first paths in this project, then plugins.
+   * This can be used in Actions to return files to clients.  If done, set `data.toRender = false` within the action.
+   * return is of the form: {connection, error, fileStream, mime, length}
+   */
+  get = async (
+    connection: Connection,
+    counter = 0,
+  ): Promise<{
+    connection: Connection;
+    error?: any;
+    mime: string;
+    length: any;
+    fileStream?: fs.ReadStream;
+    lastModified?: Date;
+  }> => {
+    let file: string;
+    if (!connection.params.file || !api.staticFile.searchPath(counter)) {
+      return api.staticFile.sendFileNotFound(
+        connection,
+        await config.errors.fileNotProvided(connection),
+      );
+    }
+
+    if (!path.isAbsolute(connection.params.file)) {
+      file = path.normalize(
+        path.join(api.staticFile.searchPath(counter), connection.params.file),
+      );
+    } else {
+      file = connection.params.file;
+    }
+
+    if (
+      file.indexOf(path.normalize(api.staticFile.searchPath(counter))) !== 0
+    ) {
+      return api.staticFile.get(connection, counter + 1);
+    } else {
+      const { exists, truePath } = await api.staticFile.checkExistence(file);
+      if (exists) {
+        return api.staticFile.sendFile(truePath, connection);
+      } else {
+        return api.staticFile.get(connection, counter + 1);
+      }
+    }
+  };
+
+  searchPath = (counter = 0) => {
+    if (
+      api.staticFile.searchLocations.length === 0 ||
+      counter >= api.staticFile.searchLocations.length
+    ) {
+      return null;
+    } else {
+      return api.staticFile.searchLocations[counter];
+    }
+  };
+
+  sendFile = async (file: string, connection: Connection) => {
+    let lastModified: Date;
+
+    try {
+      const stats = await asyncStats(file);
+      const mime = Mime.getType(file);
+      const length = stats.size;
+      const start = new Date().getTime();
+      lastModified = stats.mtime;
+
+      const fileStream = fs.createReadStream(file);
+      api.staticFile.fileLogger(fileStream, connection, start, file, length);
+
+      await new Promise((resolve) => {
+        fileStream.on("open", () => {
+          resolve(null);
+        });
+      });
+
+      return { connection, fileStream, mime, length, lastModified };
+    } catch (error) {
+      return api.staticFile.sendFileNotFound(
+        connection,
+        await config.errors.fileReadError(connection, error),
+      );
+    }
+  };
+
+  fileLogger = (
+    fileStream: any,
+    connection: Connection,
+    start: number,
+    file: string,
+    length: number | bigint,
+  ) => {
+    fileStream.on("end", () => {
+      const duration = new Date().getTime() - start;
+      api.staticFile.logRequest(file, connection, length, duration, true);
+    });
+
+    fileStream.on("error", (error: NodeJS.ErrnoException) => {
+      throw error;
+    });
+  };
+
+  sendFileNotFound = async (connection: Connection, errorMessage: string) => {
+    connection.error = new Error(errorMessage);
+    api.staticFile.logRequest("{not found}", connection, null, null, false);
+    const response = await config.errors.fileNotFound(connection);
+    return {
+      connection,
+      error: response,
+      mime: "text/html",
+      length: response.length,
+    };
+  };
+
+  checkExistence = async (
+    file: string,
+  ): Promise<{ exists: boolean; truePath: string }> => {
+    try {
+      const stats = await asyncStats(file);
+
+      if (stats.isDirectory()) {
+        const indexPath = file + "/" + config.general.directoryFileType;
+        return api.staticFile.checkExistence(indexPath);
+      }
+
+      if (stats.isSymbolicLink()) {
+        let truePath = await asyncReadLink(file);
+        truePath = path.normalize(truePath);
+        return api.staticFile.checkExistence(truePath);
+      }
+
+      if (stats.isFile()) {
+        return { exists: true, truePath: file };
+      }
+
+      return { exists: false, truePath: file };
+    } catch (error) {
+      return { exists: false, truePath: file };
+    }
+  };
+
+  logRequest = (
+    file: string,
+    connection: Connection,
+    length: number | bigint,
+    duration: number,
+    success: boolean,
+  ) => {
+    log(`[ file @ ${connection.type} ]`, config.general.fileRequestLogLevel, {
+      to: connection.remoteIP,
+      file: file,
+      requestedFile: connection.params.file,
+      size: length,
+      duration: duration,
+      success: success,
+    });
+  };
+
+  async initialize() {
+    api.staticFile = {
+      searchLocations: [],
+      get: this.get,
+      searchPath: this.searchPath,
+      sendFile: this.sendFile,
+      fileLogger: this.fileLogger,
+      sendFileNotFound: this.sendFileNotFound,
+      checkExistence: this.checkExistence,
+      logRequest: this.logRequest,
+    };
+
+    // load in the explicit public paths first
+    if (config.general.paths) {
+      config.general.paths.public.forEach(function (p: string) {
+        api.staticFile.searchLocations.push(path.normalize(p));
+      });
+    }
+
+    // source the public directories from plugins
+    for (const plugin of Object.values(config.plugins as PluginConfig)) {
+      if (plugin.public !== false) {
+        const pluginPublicPath: string = path.normalize(
+          path.join(plugin.path, "public"),
+        );
+
+        if (
+          fs.existsSync(pluginPublicPath) &&
+          api.staticFile.searchLocations.indexOf(pluginPublicPath) < 0
+        ) {
+          api.staticFile.searchLocations.push(pluginPublicPath);
+        }
+      }
+    }
+
+    log(
+      "static files will be served from these directories",
+      "debug",
+      api.staticFile.searchLocations,
+    );
+  }
+}
+
+async function asyncStats(
+  file: string,
+): Promise<ReturnType<typeof fs.statSync>> {
+  return new Promise((resolve, reject) => {
+    fs.stat(file, (error, stats) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve(stats);
+    });
+  });
+}
+
+async function asyncReadLink(file: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    fs.readlink(file, (error, linkString) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve(linkString);
+    });
+  });
+}