pepr 0.2.10 → 0.3.0-rc0

package/dist/src/cli/init/utils.test.js

@@ -0,0 +1,29 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ava_1 = __importDefault(require("ava"));
+const utils_1 = require("./utils");
+(0, ava_1.default)("sanitizeName() sanitizes names correctly", t => {
+    const cases = [
+        {
+            input: "My Test Module",
+            expected: "my-test-module",
+        },
+        {
+            input: "!! 123 @@ Module",
+            expected: "123-module",
+        },
+        {
+            input: "---Test-Module---",
+            expected: "test-module",
+        },
+    ];
+    for (const { input, expected } of cases) {
+        const result = (0, utils_1.sanitizeName)(input);
+        t.is(result, expected, `sanitizeName(${input}) should be ${expected}`);
+    }
+});

package/dist/src/cli/init/walkthrough.js

@@ -35,7 +35,7 @@ function walkthrough() {
     const askErrorBehavior = {
         type: "select",
         name: "errorBehavior",
-        validate: val => types_1.ErrorBehavior[val],
+        validate: (val) => types_1.ErrorBehavior[val],
         message: "How do you want Pepr to handle errors encountered during K8s operations?",
         choices: [
             {

package/dist/src/cli/init/walkthrough.test.js

@@ -0,0 +1,21 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ava_1 = __importDefault(require("ava"));
+const prompts_1 = __importDefault(require("prompts"));
+const walkthrough_1 = require("./walkthrough");
+(0, ava_1.default)("walkthrough() returns expected results", async (t) => {
+    // Inject predefined answers for the prompts
+    prompts_1.default.inject(["My Test Module", "A test module for Pepr", 0]);
+    const result = await (0, walkthrough_1.walkthrough)();
+    // Check the returned object
+    t.deepEqual(result, {
+        name: "My Test Module",
+        description: "A test module for Pepr",
+        errorBehavior: 0,
+    });
+});

package/dist/src/cli/run.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
@@ -5,32 +6,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
+const child_process_1 = require("child_process");
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const zlib_1 = require("zlib");
 const package_json_1 = require("../../package.json");
 const logger_1 = __importDefault(require("../lib/logger"));
-commander_1.program
-    .version(package_json_1.version)
-    .description(`Pepr Kubernetes Runtime (v${package_json_1.version})`)
-    .argument("<hash>", "Hash of the module to run")
-    .option("-l, --log-level [level]", "Log level: debug, info, warn, error", "info")
-    .action((expectedHash, opts) => {
-    const gzPath = `/app/load/module-${expectedHash}.js.gz`;
-    const jsPath = `/app/module-${expectedHash}.js`;
-    // Require the has to be 64 characters long
-    if (expectedHash.length !== 64) {
+function validateHash(expectedHash) {
+    // Require the hash to be 64 characters long
+    if (!expectedHash || expectedHash.length !== 64) {
         logger_1.default.error("Invalid hash");
         process.exit(1);
     }
+}
+function runModule(expectedHash) {
+    const gzPath = `/app/load/module-${expectedHash}.js.gz`;
+    const jsPath = `/app/module-${expectedHash}.js`;
+    // Set the log level
+    logger_1.default.SetLogLevel("debug");
     // Check if the path is a valid file
     if (!fs_1.default.existsSync(gzPath)) {
         logger_1.default.error(`File not found: ${gzPath}`);
         process.exit(1);
     }
-    // Set the log level
-    logger_1.default.SetLogLevel(opts.logLevel);
     try {
         logger_1.default.info(`Loading module ${gzPath}`);
         // Extract the code from the file
@@ -47,12 +45,14 @@ commander_1.program
         // Write the code to a file
         fs_1.default.writeFileSync(jsPath, code);
         // Run the module
-        // @todo: evaluate vm (isolate) vs require
-        require(jsPath);
+        (0, child_process_1.fork)(jsPath);
     }
     catch (e) {
         logger_1.default.error(`Failed to decompress module: ${e}`);
         process.exit(1);
     }
-});
-commander_1.program.parse();
+}
+logger_1.default.info(`Pepr Controller (v${package_json_1.version})`);
+const hash = process.argv[2];
+validateHash(hash);
+runModule(hash);

package/dist/src/cli/update.js

@@ -48,7 +48,9 @@ function default_1(program) {
         }
         catch (e) {
             logger_1.default.debug(e);
-            logger_1.default.error(e.message);
+            if (e instanceof Error) {
+                logger_1.default.error(e.message);
+            }
             process.exit(1);
         }
     });

package/dist/src/lib/capability.js

@@ -56,7 +56,7 @@ class Capability {
                     labels: {},
                     annotations: {},
                 },
-                callback: () => null,
+                callback: () => undefined,
             };
             const prefix = `${this._name}: ${model.name}`;
             logger_1.default.info(`Binding created`, prefix);

package/dist/src/lib/controller.js

@@ -29,11 +29,19 @@ class Controller {
                 throw new Error("Cannot start Pepr module: Pepr module was not instantiated with deferStart=true");
             }
             // Create HTTPS server
-            https_1.default.createServer(options, this.app).listen(port, () => {
+            const server = https_1.default.createServer(options, this.app).listen(port, () => {
                 console.log(`Server listening on port ${port}`);
                 // Track that the server is running
                 this.running = true;
             });
+            // Listen for the SIGTERM signal and gracefully close the server
+            process.on("SIGTERM", () => {
+                console.log("Received SIGTERM, closing server");
+                server.close(() => {
+                    console.log("Server closed");
+                    process.exit(0);
+                });
+            });
         };
         this.logger = (req, res, next) => {
             const startTime = Date.now();

package/dist/src/lib/fetch.js

@@ -1,13 +1,36 @@
 "use strict";
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetch = exports.fetchRaw = void 0;
 const http_status_codes_1 = require("http-status-codes");
-const node_fetch_1 = __importDefault(require("node-fetch"));
+const node_fetch_1 = __importStar(require("node-fetch"));
 exports.fetchRaw = node_fetch_1.default;
 const logger_1 = __importDefault(require("./logger"));
 /**
@@ -24,11 +47,11 @@ const logger_1 = __importDefault(require("./logger"));
  * @returns
  */
 async function fetch(url, init) {
+    let data = undefined;
     try {
         logger_1.default.debug(`Fetching ${url}`);
         const resp = await (0, node_fetch_1.default)(url, init);
         const contentType = resp.headers.get("content-type") || "";
-        let data;
         if (resp.ok) {
             // Parse the response as JSON if the content type is JSON
             if (contentType.includes("application/json")) {
@@ -47,12 +70,22 @@ async function fetch(url, init) {
         };
     }
     catch (e) {
-        logger_1.default.debug(`Fetch failed: ${e.message}`);
+        if (e instanceof node_fetch_1.FetchError) {
+            logger_1.default.debug(`Fetch failed: ${e instanceof Error ? e.message : e}`);
+            // Parse the error code from the FetchError or default to 400 (Bad Request)
+            const status = parseInt(e.code || "400");
+            return {
+                data,
+                ok: false,
+                status,
+                statusText: e.message,
+            };
+        }
         return {
-            data: null,
+            data,
             ok: false,
-            status: e.code || http_status_codes_1.StatusCodes.BAD_REQUEST,
-            statusText: e.message,
+            status: http_status_codes_1.StatusCodes.BAD_REQUEST,
+            statusText: "Unknown error",
         };
     }
 }

package/dist/src/lib/fetch.test.js

@@ -0,0 +1,98 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+// fetch.test.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ava_1 = __importDefault(require("ava"));
+const http_status_codes_1 = require("http-status-codes");
+const nock_1 = __importDefault(require("nock"));
+const fetch_1 = require("./fetch");
+ava_1.default.beforeEach(() => {
+    (0, nock_1.default)("https://jsonplaceholder.typicode.com")
+        .get("/todos/1")
+        .reply(200, {
+        userId: 1,
+        id: 1,
+        title: "Example title",
+        completed: false,
+    })
+        .post("/todos", {
+        title: "test todo",
+        userId: 1,
+        completed: false,
+    })
+        .reply(200, (uri, requestBody) => requestBody)
+        .get("/todos/empty-null")
+        .reply(200, undefined)
+        .get("/todos/empty-string")
+        .reply(200, "")
+        .get("/todos/empty-object")
+        .reply(200, {})
+        .get("/todos/invalid")
+        .replyWithError("Something bad happened");
+});
+(0, ava_1.default)("fetch: should return without type data", async (t) => {
+    const url = "https://jsonplaceholder.typicode.com/todos/1";
+    const { data, ok } = await (0, fetch_1.fetch)(url);
+    t.is(ok, true);
+    t.is(data["title"], "Example title");
+});
+(0, ava_1.default)("fetch: should return parsed JSON response as a specific type", async (t) => {
+    const url = "https://jsonplaceholder.typicode.com/todos/1";
+    const { data, ok } = await (0, fetch_1.fetch)(url);
+    t.is(ok, true);
+    t.is(data.id, 1);
+    t.is(typeof data.title, "string");
+    t.is(typeof data.completed, "boolean");
+});
+(0, ava_1.default)("fetch: should handle additional request options", async (t) => {
+    const url = "https://jsonplaceholder.typicode.com/todos";
+    const requestOptions = {
+        method: "POST",
+        body: JSON.stringify({
+            title: "test todo",
+            userId: 1,
+            completed: false,
+        }),
+        headers: {
+            "Content-type": "application/json; charset=UTF-8",
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { data, ok } = await (0, fetch_1.fetch)(url, requestOptions);
+    t.is(ok, true);
+    t.is(data["title"], "test todo");
+    t.is(data["userId"], 1);
+    t.is(data["completed"], false);
+});
+(0, ava_1.default)("fetch: should handle empty (null) responses", async (t) => {
+    const url = "https://jsonplaceholder.typicode.com/todos/empty-null";
+    const resp = await (0, fetch_1.fetch)(url);
+    t.is(resp.data, "");
+    t.is(resp.ok, true);
+    t.is(resp.status, http_status_codes_1.StatusCodes.OK);
+});
+(0, ava_1.default)("fetch: should handle empty (string) responses", async (t) => {
+    const url = "https://jsonplaceholder.typicode.com/todos/empty-string";
+    const resp = await (0, fetch_1.fetch)(url);
+    t.is(resp.data, "");
+    t.is(resp.ok, true);
+    t.is(resp.status, http_status_codes_1.StatusCodes.OK);
+});
+(0, ava_1.default)("fetch: should handle empty (object) responses", async (t) => {
+    const url = "https://jsonplaceholder.typicode.com/todos/empty-object";
+    const resp = await (0, fetch_1.fetch)(url);
+    t.deepEqual(resp.data, {});
+    t.is(resp.ok, true);
+    t.is(resp.status, http_status_codes_1.StatusCodes.OK);
+});
+(0, ava_1.default)("fetch: should handle failed requests without throwing an error", async (t) => {
+    const url = "https://jsonplaceholder.typicode.com/todos/invalid";
+    const resp = await (0, fetch_1.fetch)(url);
+    t.is(resp.data, undefined);
+    t.is(resp.ok, false);
+    t.is(resp.status, http_status_codes_1.StatusCodes.BAD_REQUEST);
+});

package/dist/src/lib/filter.test.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ava_1 = __importDefault(require("ava"));
+const loader_1 = require("../../fixtures/loader");
+const filter_1 = require("./filter");
+const k8s_1 = require("./k8s");
+const callback = () => undefined;
+(0, ava_1.default)("should reject when name does not match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "bleh",
+            namespaces: [],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.true((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should reject when kind does not match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1ConfigMap,
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.true((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should reject when group does not match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1CronJob,
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.true((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should reject when version does not match", t => {
+    const binding = {
+        kind: {
+            group: "",
+            version: "v2",
+            kind: "Pod",
+        },
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.true((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should allow when group, version, and kind match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.false((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should allow when kind match and others are empty", t => {
+    const binding = {
+        kind: {
+            group: "",
+            version: "",
+            kind: "Pod",
+        },
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.false((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should reject when namespace does not match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "",
+            namespaces: ["bleh"],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.true((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should allow when namespace is match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "",
+            namespaces: ["default", "unicorn", "things"],
+            labels: {},
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.false((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should reject when label does not match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {
+                foo: "bar",
+            },
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.true((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should allow when label is match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {
+                foo: "bar",
+                test: "test1",
+            },
+            annotations: {},
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    pod.object.metadata = pod.object.metadata || {};
+    pod.object.metadata.labels = {
+        foo: "bar",
+        test: "test1",
+        test2: "test2",
+    };
+    t.false((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should reject when annotation does not match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {},
+            annotations: {
+                foo: "bar",
+            },
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    t.true((0, filter_1.shouldSkipRequest)(binding, pod));
+});
+(0, ava_1.default)("should allow when annotation is match", t => {
+    const binding = {
+        kind: k8s_1.gvkMap.V1Pod,
+        filters: {
+            name: "",
+            namespaces: [],
+            labels: {},
+            annotations: {
+                foo: "bar",
+                test: "test1",
+            },
+        },
+        callback,
+    };
+    const pod = (0, loader_1.POD1)();
+    pod.object.metadata = pod.object.metadata || {};
+    pod.object.metadata.annotations = {
+        foo: "bar",
+        test: "test1",
+        test2: "test2",
+    };
+    t.false((0, filter_1.shouldSkipRequest)(binding, pod));
+});