0z2i6v3u5t 1.0.0

package/src/initializers/redis.ts

@@ -0,0 +1,191 @@
+import * as IORedis from "ioredis";
+import * as dotProp from "dot-prop";
+import { api, config, id, log, Initializer, redis, utils } from "../index";
+import * as RedisModule from "./../modules/redis";
+
+export interface RedisApi {
+  clients: {
+    [key: string]: IORedis.Redis;
+  };
+  subscriptionHandlers: {
+    [key: string]: Function;
+  };
+  rpcCallbacks: {
+    [key: string]: any;
+  };
+  status: {
+    subscribed: boolean;
+  };
+}
+
+/**
+ * Redis helpers and connections.
+ */
+export class RedisInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "redis";
+    this.loadPriority = 200;
+    this.startPriority = 101;
+    this.stopPriority = 99999;
+  }
+
+  async initialize() {
+    api.redis = {
+      clients: {},
+      subscriptionHandlers: {},
+      rpcCallbacks: {},
+      status: {
+        subscribed: false,
+      },
+    };
+
+    api.redis.subscriptionHandlers.do = async (
+      message: RedisModule.redis.PubSubMessage,
+    ) => {
+      if (
+        !message.connectionId ||
+        (api.connections && api.connections.connections[message.connectionId])
+      ) {
+        const cmdParts = message.method.split(".");
+        const cmd = cmdParts.shift();
+        if (cmd !== "api") {
+          throw new Error(
+            "cannot operate on a method outside of the api object",
+          );
+        }
+
+        const callableApi = Object.assign(api, { log });
+
+        const method: Function = dotProp.get(callableApi, cmdParts.join("."));
+        let args = message.args;
+        if (args === null) {
+          args = [];
+        }
+        if (!Array.isArray(args)) {
+          args = [args];
+        }
+        if (method) {
+          const response = await method.apply(null, args);
+          await redis.respondCluster(message.messageId, response);
+        } else {
+          log("RPC method `" + cmdParts.join(".") + "` not found", "crit");
+        }
+      }
+    };
+
+    api.redis.subscriptionHandlers.doResponse = function (
+      message: RedisModule.redis.PubSubMessage,
+    ) {
+      if (api.redis.rpcCallbacks[message.messageId]) {
+        const { resolve, timer } = api.redis.rpcCallbacks[message.messageId];
+        clearTimeout(timer);
+        resolve(message.response);
+        delete api.redis.rpcCallbacks[message.messageId];
+      }
+    };
+
+    const connectionNames = ["client", "subscriber", "tasks"] as const;
+    for (const r of connectionNames) {
+      if (config.redis[r].buildNew === true) {
+        api.redis.clients[r] = new config.redis[r].konstructor(
+          ...(config.redis[r].args ?? []),
+        );
+
+        api.redis.clients[r].on("error", (error) => {
+          log(`Redis connection \`${r}\` error`, "alert", error);
+        });
+
+        api.redis.clients[r].on("connect", () => {
+          log(`Redis connection \`${r}\` connected`, "debug");
+        });
+
+        api.redis.clients[r].on("ready", () => {
+          log(`Redis connection \`${r}\` ready`, "debug");
+        });
+
+        api.redis.clients[r].on("close", () => {
+          log(`Redis connection \`${r}\` closed`, "debug");
+        });
+
+        api.redis.clients[r].on("end", () => {
+          log(`Redis connection \`${r}\` ended`, "debug");
+        });
+
+        api.redis.clients[r].on("reconnecting", () => {
+          log(`Redis connection \`${r}\` reconnecting`, "info");
+        });
+      } else {
+        api.redis.clients[r] = config.redis[r].konstructor(
+          config.redis[r].args,
+        );
+        api.redis.clients[r].on("error", (error) => {
+          log(`Redis connection \`${r}\` error`, "alert", error);
+        });
+        log(`Redis connection \`${r}\` connected`, "debug");
+      }
+
+      if (r !== "subscriber") await api.redis.clients[r].get("_test");
+    }
+
+    if (!api.redis.status.subscribed) {
+      await api.redis.clients.subscriber.subscribe(config.general.channel);
+      api.redis.status.subscribed = true;
+
+      const messageHandler = async (
+        messageChannel: string,
+        stringifiedMessage: string,
+      ) => {
+        let message: RedisModule.redis.PubSubMessage;
+        try {
+          message = JSON.parse(stringifiedMessage);
+        } catch (e) {
+          message = {};
+        }
+
+        if (
+          messageChannel === config.general.channel &&
+          message.serverToken === config.general.serverToken
+        ) {
+          if (api.redis.subscriptionHandlers[message.messageType]) {
+            await api.redis.subscriptionHandlers[message.messageType](message);
+          }
+        }
+      };
+
+      api.redis.clients.subscriber.on("message", messageHandler);
+    }
+  }
+
+  async start() {
+    await redis.doCluster("api.log", [
+      `actionhero member ${id} has joined the cluster`,
+    ]);
+  }
+
+  async stop() {
+    await api.redis.clients.subscriber.unsubscribe();
+    api.redis.status.subscribed = false;
+    await redis.doCluster("api.log", [
+      `actionhero member ${id} has left the cluster`,
+    ]);
+
+    await utils.sleep(config.redis.stopTimeout); // allow some time for the goodbye message to propagate
+
+    const keys = Object.keys(api.redis.clients);
+    for (const i in keys) {
+      const client = api.redis.clients[keys[i]];
+      //@ts-ignore
+      if (typeof client.end === "function") {
+        //@ts-ignore
+        await client.end();
+      } else if (typeof client.quit === "function") {
+        await client.quit();
+      } else if (typeof client.disconnect === "function") {
+        await client.disconnect();
+      }
+    }
+
+    await utils.sleep(config.redis.stopTimeout); // allow some time for the connection to close
+  }
+}

package/src/initializers/resque.ts

@@ -0,0 +1,248 @@
+import { Queue, Scheduler, MultiWorker, ParsedJob } from "node-resque";
+import { api, config, log, utils, Initializer } from "../index";
+
+export interface ResqueApi {
+  connectionDetails: {
+    [key: string]: any;
+  };
+  queue: Queue;
+  scheduler: Scheduler;
+  multiWorker: MultiWorker;
+  startQueue: ResqueInitializer["startQueue"];
+  stopQueue: ResqueInitializer["stopQueue"];
+  startScheduler: ResqueInitializer["startScheduler"];
+  stopScheduler: ResqueInitializer["stopScheduler"];
+  startMultiWorker: ResqueInitializer["startMultiWorker"];
+  stopMultiWorker: ResqueInitializer["stopMultiWorker"];
+}
+
+/**
+ * The node-resque workers and scheduler which process tasks.
+ * see https://github.com/actionhero/node-resque
+ */
+export class ResqueInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "resque";
+    this.loadPriority = 600;
+    this.startPriority = 950;
+    this.stopPriority = 100;
+  }
+
+  startQueue = async () => {
+    api.resque.queue = new Queue(
+      { connection: api.resque.connectionDetails },
+      api.tasks.jobs,
+    );
+
+    api.resque.queue.on("error", (error) => {
+      log(error.toString(), "error", "[api.resque.queue]");
+    });
+
+    await api.resque.queue.connect();
+  };
+
+  stopQueue = () => {
+    if (api.resque.queue) {
+      return api.resque.queue.end();
+    }
+  };
+
+  startScheduler = async () => {
+    if (config.tasks.scheduler === true) {
+      api.resque.scheduler = new Scheduler({
+        connection: api.resque.connectionDetails,
+        timeout: config.tasks.timeout,
+        stuckWorkerTimeout: config.tasks.stuckWorkerTimeout,
+        retryStuckJobs: config.tasks.retryStuckJobs,
+      });
+
+      api.resque.scheduler.on("error", (error) => {
+        log(error.toString(), "error", "[api.resque.scheduler]");
+      });
+
+      await api.resque.scheduler.connect();
+      api.resque.scheduler.on("start", () => {
+        log("resque scheduler started", config.tasks.schedulerLogging.start);
+      });
+      api.resque.scheduler.on("end", () => {
+        log("resque scheduler ended", config.tasks.schedulerLogging.end);
+      });
+      api.resque.scheduler.on("poll", () => {
+        log("resque scheduler polling", config.tasks.schedulerLogging.poll);
+      });
+      api.resque.scheduler.on("leader", () => {
+        log("This node is now the Resque scheduler leader", "notice");
+      });
+      api.resque.scheduler.on(
+        "cleanStuckWorker",
+        (workerName, errorPayload, delta) => {
+          log("cleaned stuck worker", "warning", {
+            workerName,
+            errorPayload,
+            delta,
+          });
+        },
+      );
+
+      api.resque.scheduler.start();
+    }
+  };
+
+  stopScheduler = async () => {
+    return api.resque.scheduler?.end();
+  };
+
+  startMultiWorker = async () => {
+    api.resque.multiWorker = new MultiWorker(
+      {
+        connection: api.resque.connectionDetails,
+        queues: Array.isArray(config.tasks.queues)
+          ? config.tasks.queues
+          : await config.tasks.queues(),
+        timeout: config.tasks.timeout,
+        checkTimeout: config.tasks.checkTimeout,
+        minTaskProcessors: config.tasks.minTaskProcessors,
+        maxTaskProcessors: config.tasks.maxTaskProcessors,
+        maxEventLoopDelay: config.tasks.maxEventLoopDelay,
+      },
+      api.tasks.jobs,
+    );
+
+    // normal worker emitters
+    api.resque.multiWorker.on("start", (workerId) => {
+      log("[ worker ] started", config.tasks.workerLogging.start, {
+        workerId,
+      });
+    });
+    api.resque.multiWorker.on("end", (workerId) => {
+      log("[ worker ] ended", config.tasks.workerLogging.end, {
+        workerId,
+      });
+    });
+    api.resque.multiWorker.on("cleaning_worker", (workerId, worker, pid) => {
+      log(
+        `[ worker ] cleaning old worker ${worker}, (${pid})`,
+        config.tasks.workerLogging.cleaning_worker,
+      );
+    });
+    api.resque.multiWorker.on("poll", (workerId, queue) => {
+      log(`[ worker ] polling ${queue}`, config.tasks.workerLogging.poll, {
+        workerId,
+      });
+    });
+    api.resque.multiWorker.on("job", (workerId, queue, job: ParsedJob) => {
+      log(`[ worker ] working job ${queue}`, config.tasks.workerLogging.job, {
+        workerId,
+        class: job.class,
+        queue: job.queue,
+        args: JSON.stringify(utils.filterObjectForLogging(job.args[0])),
+      });
+    });
+    api.resque.multiWorker.on(
+      "reEnqueue",
+      (workerId, queue, job: ParsedJob, plugin) => {
+        log("[ worker ] reEnqueue task", config.tasks.workerLogging.reEnqueue, {
+          workerId,
+          plugin: JSON.stringify(plugin),
+          class: job.class,
+          queue: job.queue,
+        });
+      },
+    );
+    api.resque.multiWorker.on("pause", (workerId) => {
+      log("[ worker ] paused", config.tasks.workerLogging.pause, {
+        workerId,
+      });
+    });
+
+    api.resque.multiWorker.on("failure", (workerId, queue, job, failure) => {
+      api.exceptionHandlers.task(failure, queue, job, workerId);
+    });
+    api.resque.multiWorker.on("error", (error, workerId, queue, job) => {
+      api.exceptionHandlers.task(error, queue, job, workerId);
+    });
+
+    api.resque.multiWorker.on(
+      "success",
+      (workerId, queue, job: ParsedJob, result, duration) => {
+        const payload = {
+          workerId,
+          class: job.class,
+          queue: job.queue,
+          args: JSON.stringify(utils.filterObjectForLogging(job.args[0])),
+          result,
+          duration,
+        };
+
+        log(
+          "[ worker ] task success",
+          config.tasks.workerLogging.success,
+          payload,
+        );
+      },
+    );
+
+    // multiWorker emitters
+    api.resque.multiWorker.on("multiWorkerAction", (verb, delay) => {
+      log(
+        `[ multiworker ] checked for worker status: ${verb} (event loop delay: ${delay}ms)`,
+        config.tasks.workerLogging.multiWorkerAction,
+      );
+    });
+
+    if (config.tasks.minTaskProcessors > 0) {
+      api.resque.multiWorker.start();
+    }
+  };
+
+  stopMultiWorker = async () => {
+    if (api.resque.multiWorker && config.tasks.minTaskProcessors > 0) {
+      return api.resque.multiWorker.stop();
+    }
+  };
+
+  async initialize() {
+    api.resque = {
+      queue: null,
+      multiWorker: null,
+      scheduler: null,
+      connectionDetails: Object.assign(
+        {},
+        config.tasks.connectionOptions.tasks,
+        {
+          redis: api.redis.clients.tasks,
+          pkg: ["RedisMock", "_RedisMock"].includes(
+            api.redis.clients.tasks?.constructor?.name,
+          )
+            ? "ioredis-mock"
+            : "ioredis",
+        },
+      ),
+      startQueue: this.startQueue,
+      stopQueue: this.stopQueue,
+      startScheduler: this.startScheduler,
+      stopScheduler: this.stopScheduler,
+      startMultiWorker: this.startMultiWorker,
+      stopMultiWorker: this.stopMultiWorker,
+    };
+  }
+
+  async start() {
+    if (
+      config.tasks.minTaskProcessors === 0 &&
+      config.tasks.maxTaskProcessors > 0
+    ) {
+      config.tasks.minTaskProcessors = 1;
+    }
+
+    await api.resque.startScheduler();
+    await api.resque.startMultiWorker();
+  }
+
+  async stop() {
+    await api.resque.stopScheduler();
+    await api.resque.stopMultiWorker();
+    await api.resque.stopQueue();
+  }
+}

package/src/initializers/routes.ts

@@ -0,0 +1,229 @@
+import * as path from "path";
+import {
+  api,
+  config,
+  log,
+  utils,
+  route,
+  Initializer,
+  RouteType,
+  Connection,
+  RouteMethod,
+} from "../index";
+import { routerMethods } from "../modules/route";
+
+export interface RoutesApi {
+  routes: { [method in RouteMethod]: RouteType[] };
+  processRoute: RoutesInitializer["processRoute"];
+  matchURL: RoutesInitializer["matchURL"];
+  loadRoutes: RoutesInitializer["loadRoutes"];
+}
+
+/**
+ * Contains routing options for web clients.  Can associate routes with actions or files.
+ */
+export class RoutesInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "routes";
+    this.loadPriority = 500;
+  }
+
+  processRoute = (connection: Connection, pathParts: string[]) => {
+    if (
+      connection.params.action === undefined ||
+      api.actions.actions[connection.params.action] === undefined
+    ) {
+      let method = connection.rawConnection.method.toLowerCase() as RouteMethod;
+      if (method === "head" && !api.routes.routes.head) method = "get";
+
+      for (const i in api.routes.routes[method]) {
+        const route = api.routes.routes[method][i];
+        const match = api.routes.matchURL(
+          pathParts,
+          route.path,
+          route.matchTrailingPathParts,
+        );
+        if (match.match) {
+          if (route.apiVersion) {
+            connection.params.apiVersion ||= route.apiVersion;
+          }
+
+          for (const param in match.params) {
+            try {
+              const decodedName = decodeURIComponent(param.replace(/\+/g, " "));
+              const decodedValue = decodeURIComponent(
+                match.params[param].replace(/\+/g, " "),
+              );
+              connection.params[decodedName] = decodedValue;
+            } catch (e) {
+              // malformed URL
+            }
+          }
+
+          connection.matchedRoute = route;
+
+          if (route.dir) {
+            const requestedFile =
+              connection.rawConnection.parsedURL.pathname.substring(
+                route.path.length,
+                connection.rawConnection.parsedURL.pathname.length,
+              );
+            connection.params.file = path.normalize(
+              route.dir + "/" + requestedFile,
+            );
+          } else {
+            connection.params.action = route.action;
+          }
+          break;
+        }
+      }
+    }
+  };
+
+  matchURL = (
+    pathParts: string[],
+    match: string,
+    matchTrailingPathParts: boolean,
+  ) => {
+    const response: { match: boolean; params: { [key: string]: any } } = {
+      match: false,
+      params: {},
+    };
+    const matchParts = match.split("/");
+    let regexpMatch: string = null;
+    let variable = "";
+
+    if (matchParts[0] === "") matchParts.splice(0, 1);
+    if (matchParts[matchParts.length - 1] === "") matchParts.pop();
+
+    if (matchParts.length !== pathParts.length && !matchTrailingPathParts) {
+      return response;
+    }
+
+    for (const i in matchParts) {
+      const matchPart = matchParts[i];
+      let pathPart = pathParts[i];
+
+      if (matchTrailingPathParts && parseInt(i) === matchParts.length - 1) {
+        for (const j in pathParts) {
+          if (j > i) pathPart = pathPart + "/" + pathParts[j];
+        }
+      }
+
+      if (!pathPart) return response;
+
+      if (matchPart.includes(":")) {
+        const trimmedMatchParts = matchPart.split(":");
+        const trimmedMatchPart =
+          trimmedMatchParts[trimmedMatchParts.length - 1];
+        const replacement = trimmedMatchParts[trimmedMatchParts.length - 2];
+        if (replacement) {
+          if (!pathPart.includes(replacement)) return response;
+          pathPart = pathPart.replace(replacement, "");
+        }
+
+        if (!trimmedMatchPart.includes("(")) {
+          variable = trimmedMatchPart;
+          response.params[variable] = pathPart;
+        } else {
+          variable = trimmedMatchPart.replace(":", "").split("(")[0];
+          regexpMatch = trimmedMatchPart.substring(
+            trimmedMatchPart.indexOf("(") + 1,
+            trimmedMatchPart.length - 1,
+          );
+          const matches = pathPart.match(new RegExp(regexpMatch, "g"));
+          if (matches) {
+            response.params[variable] = pathPart;
+          } else {
+            return response;
+          }
+        }
+      } else {
+        if (
+          pathPart === null ||
+          pathPart === undefined ||
+          pathParts[i].toLowerCase() !== matchPart.toLowerCase()
+        ) {
+          return response;
+        }
+      }
+    }
+
+    response.match = true;
+    return response;
+  };
+
+  loadRoutes = (rawRoutes?: (typeof config)["routes"]) => {
+    let counter = 0;
+
+    if (!rawRoutes) if (config.routes) rawRoutes = config.routes;
+
+    for (const [method, collection] of Object.entries(rawRoutes)) {
+      for (const configRoute of collection as RouteType[]) {
+        if (method === "all") {
+          for (const verb of routerMethods) {
+            route.registerRoute(
+              verb as RouteMethod,
+              configRoute.path,
+              configRoute.action,
+              configRoute.apiVersion,
+              configRoute.matchTrailingPathParts,
+              configRoute.dir,
+            );
+          }
+        } else {
+          route.registerRoute(
+            method as RouteMethod,
+            configRoute.path,
+            configRoute.action,
+            configRoute.apiVersion,
+            configRoute.matchTrailingPathParts,
+            configRoute.dir,
+          );
+        }
+        counter++;
+      }
+    }
+
+    api.params.postVariables = utils.arrayUnique(api.params.postVariables);
+
+    if (config.web && Array.isArray(config.web.automaticRoutes)) {
+      config.web.automaticRoutes.forEach((verb: RouteMethod) => {
+        if (!routerMethods.includes(verb)) {
+          throw new Error(`${verb} is not an HTTP verb`);
+        }
+
+        log(
+          `creating routes automatically for all actions responding to ${verb.toUpperCase()} HTTP verb`,
+        );
+
+        for (const action in api.actions.actions) {
+          route.registerRoute(verb, "/" + action, action, null);
+        }
+      });
+    }
+
+    log("routes:", "debug", api.routes.routes);
+    return counter;
+  };
+
+  async initialize() {
+    api.routes = {
+      routes: {
+        all: [],
+        head: [],
+        get: [],
+        patch: [],
+        post: [],
+        put: [],
+        delete: [],
+      },
+      processRoute: this.processRoute,
+      matchURL: this.matchURL,
+      loadRoutes: this.loadRoutes,
+    };
+
+    api.routes.loadRoutes();
+  }
+}