cdk8s-plus-36 0.0.1 → 2.0.0

package/lib/probe.d.ts

@@ -0,0 +1,181 @@
+import { Duration } from 'cdk8s';
+import * as container from './container';
+import * as k8s from './imports/k8s';
+/**
+ * Probe options.
+ */
+export interface ProbeOptions {
+    /**
+     * Minimum consecutive failures for the probe to be considered failed after
+     * having succeeded.
+     *
+     * Defaults to 3. Minimum value is 1.
+     *
+     * @default 3
+     */
+    readonly failureThreshold?: number;
+    /**
+     * Number of seconds after the container has started before liveness probes
+     * are initiated.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
+     * @default - immediate
+     */
+    readonly initialDelaySeconds?: Duration;
+    /**
+     * How often (in seconds) to perform the probe.
+     *
+     * Default to 10 seconds. Minimum value is 1.
+     *
+     * @default Duration.seconds(10) Minimum value is 1.
+     */
+    readonly periodSeconds?: Duration;
+    /**
+     * Minimum consecutive successes for the probe to be considered successful
+     * after having failed. Defaults to 1.
+     *
+     * Must be 1 for liveness and startup. Minimum value is 1.
+     *
+     * @default 1 Must be 1 for liveness and startup. Minimum value is 1.
+     */
+    readonly successThreshold?: number;
+    /**
+     * Number of seconds after which the probe times out.
+     *
+     * Defaults to 1 second. Minimum value is 1.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
+     * @default Duration.seconds(1)
+     */
+    readonly timeoutSeconds?: Duration;
+}
+export declare enum ConnectionScheme {
+    /**
+     * Use HTTP request for connecting to host.
+     */
+    HTTP = "HTTP",
+    /**
+     * Use HTTPS request for connecting to host.
+     */
+    HTTPS = "HTTPS"
+}
+export interface HttpHeader {
+    /**
+     * The HTTP Header name to be used
+     */
+    readonly name: string;
+    /**
+     * The HTTP header value to be set
+     */
+    readonly value: string;
+}
+/**
+ * Options for `Probe.fromHttpGet()`.
+ */
+export interface HttpGetProbeOptions extends ProbeOptions {
+    /**
+     * The TCP port to use when sending the GET request.
+     *
+     * @default - defaults to `container.port`.
+     */
+    readonly port?: number;
+    /**
+     *  Scheme to use for connecting to the host (HTTP or HTTPS).
+     *
+     *  @default ConnectionScheme.HTTP
+     */
+    readonly scheme?: ConnectionScheme;
+    /**
+     * The host name to connect to on the container.
+     *
+     * @default - defaults to the pod IP
+     */
+    readonly host?: string;
+    /**
+     * Custom HTTP headers to set in the probe request. Note that HTTP allows repeated headers.
+     *
+     * @default - no custom headers are set
+     */
+    readonly httpHeaders?: HttpHeader[];
+}
+/**
+ * Options for `Probe.fromCommand()`.
+ */
+export interface CommandProbeOptions extends ProbeOptions {
+}
+/**
+ * Options for `Probe.fromTcpSocket()`.
+ */
+export interface TcpSocketProbeOptions extends ProbeOptions {
+    /**
+     * The TCP port to connect to on the container.
+     *
+     * @default - defaults to `container.port`.
+     */
+    readonly port?: number;
+    /**
+     * The host name to connect to on the container.
+     *
+     * @default - defaults to the pod IP
+     */
+    readonly host?: string;
+}
+/**
+ * Options for `Probe.fromGrpc()`.
+ */
+export interface GrpcProbeOptions extends ProbeOptions {
+    /**
+     * The TCP port to connect to on the container.
+     *
+     * @default - defaults to `container.port`.
+     */
+    readonly port?: number;
+    /**
+     * Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
+     *
+     * @default - If this is not specified, the default behavior is defined by gRPC.
+     */
+    readonly service?: string;
+}
+/**
+ * Probe describes a health check to be performed against a container to
+ * determine whether it is alive or ready to receive traffic.
+ */
+export declare class Probe {
+    private readonly probeOptions;
+    private readonly tcpSocketOptions?;
+    private readonly commandOptions?;
+    private readonly httpGetOptions?;
+    private readonly grpcOptions?;
+    /**
+     * Defines a probe based on an HTTP GET request to the IP address of the container.
+     *
+     * @param path The URL path to hit
+     * @param options Options
+     */
+    static fromHttpGet(path: string, options?: HttpGetProbeOptions): Probe;
+    /**
+     * Defines a probe based on a command which is executed within the container.
+     *
+     * @param command The command to execute
+     * @param options Options
+     */
+    static fromCommand(command: string[], options?: CommandProbeOptions): Probe;
+    /**
+     * Defines a probe based opening a connection to a TCP socket on the container.
+     *
+     * @param options Options
+     */
+    static fromTcpSocket(options?: TcpSocketProbeOptions): Probe;
+    /**
+     * Defines a probe based on a gRPC request to the container.
+     *
+     * @param options Options
+     */
+    static fromGrpc(options?: GrpcProbeOptions): Probe;
+    private constructor();
+    /**
+     * @internal
+     */
+    _toKube(cont: container.Container): k8s.Probe;
+}

package/lib/probe.js

@@ -0,0 +1,124 @@
+"use strict";
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Probe = exports.ConnectionScheme = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const _action = __importStar(require("./_action"));
+var ConnectionScheme;
+(function (ConnectionScheme) {
+    /**
+     * Use HTTP request for connecting to host.
+     */
+    ConnectionScheme["HTTP"] = "HTTP";
+    /**
+     * Use HTTPS request for connecting to host.
+     */
+    ConnectionScheme["HTTPS"] = "HTTPS";
+})(ConnectionScheme || (exports.ConnectionScheme = ConnectionScheme = {}));
+/**
+ * Probe describes a health check to be performed against a container to
+ * determine whether it is alive or ready to receive traffic.
+ */
+class Probe {
+    probeOptions;
+    tcpSocketOptions;
+    commandOptions;
+    httpGetOptions;
+    grpcOptions;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Probe", version: "2.0.0" };
+    /**
+     * Defines a probe based on an HTTP GET request to the IP address of the container.
+     *
+     * @param path The URL path to hit
+     * @param options Options
+     */
+    static fromHttpGet(path, options = {}) {
+        return new Probe(options, undefined, undefined, { path, ...options }, undefined);
+    }
+    /**
+     * Defines a probe based on a command which is executed within the container.
+     *
+     * @param command The command to execute
+     * @param options Options
+     */
+    static fromCommand(command, options = {}) {
+        return new Probe(options, undefined, { command, ...options }, undefined, undefined);
+    }
+    /**
+     * Defines a probe based opening a connection to a TCP socket on the container.
+     *
+     * @param options Options
+     */
+    static fromTcpSocket(options = {}) {
+        return new Probe(options, options, undefined, undefined, undefined);
+    }
+    /**
+     * Defines a probe based on a gRPC request to the container.
+     *
+     * @param options Options
+     */
+    static fromGrpc(options = {}) {
+        return new Probe(options, undefined, undefined, undefined, options);
+    }
+    constructor(probeOptions, tcpSocketOptions, commandOptions, httpGetOptions, grpcOptions) {
+        this.probeOptions = probeOptions;
+        this.tcpSocketOptions = tcpSocketOptions;
+        this.commandOptions = commandOptions;
+        this.httpGetOptions = httpGetOptions;
+        this.grpcOptions = grpcOptions;
+    }
+    /**
+     * @internal
+     */
+    _toKube(cont) {
+        const exec = this.commandOptions ? _action.Action.fromCommand(this.commandOptions.command) : undefined;
+        const httpGet = this.httpGetOptions ? _action.Action.fromHttpGet(cont, this.httpGetOptions.path, this.httpGetOptions) : undefined;
+        const tcpSocket = this.tcpSocketOptions ? _action.Action.fromTcpSocket(cont, this.tcpSocketOptions) : undefined;
+        const grpc = this.grpcOptions ? _action.Action.fromGrpc(cont, this.grpcOptions) : undefined;
+        return {
+            failureThreshold: this.probeOptions.failureThreshold ?? 3,
+            initialDelaySeconds: this.probeOptions.initialDelaySeconds ? this.probeOptions.initialDelaySeconds.toSeconds() : undefined,
+            periodSeconds: this.probeOptions.periodSeconds ? this.probeOptions.periodSeconds.toSeconds() : undefined,
+            successThreshold: this.probeOptions.successThreshold,
+            timeoutSeconds: this.probeOptions.timeoutSeconds ? this.probeOptions.timeoutSeconds.toSeconds() : undefined,
+            exec: exec,
+            httpGet,
+            tcpSocket,
+            grpc,
+        };
+    }
+}
+exports.Probe = Probe;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"probe.js","sourceRoot":"","sources":["../src/probe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration } from 'cdk8s';\nimport * as _action from './_action';\nimport * as container from './container';\nimport * as k8s from './imports/k8s';\n\n/**\n * Probe options.\n */\nexport interface ProbeOptions {\n  /**\n   * Minimum consecutive failures for the probe to be considered failed after\n   * having succeeded.\n   *\n   * Defaults to 3. Minimum value is 1.\n   *\n   * @default 3\n   */\n  readonly failureThreshold?: number;\n\n  /**\n   * Number of seconds after the container has started before liveness probes\n   * are initiated.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\n   * @default - immediate\n   */\n  readonly initialDelaySeconds?: Duration;\n\n  /**\n   * How often (in seconds) to perform the probe.\n   *\n   * Default to 10 seconds. Minimum value is 1.\n   *\n   * @default Duration.seconds(10) Minimum value is 1.\n   */\n  readonly periodSeconds?: Duration;\n\n  /**\n   * Minimum consecutive successes for the probe to be considered successful\n   * after having failed. Defaults to 1.\n   *\n   * Must be 1 for liveness and startup. Minimum value is 1.\n   *\n   * @default 1 Must be 1 for liveness and startup. Minimum value is 1.\n   */\n  readonly successThreshold?: number;\n\n  /**\n   * Number of seconds after which the probe times out.\n   *\n   * Defaults to 1 second. Minimum value is 1.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes\n   * @default Duration.seconds(1)\n   */\n  readonly timeoutSeconds?: Duration;\n}\n\nexport enum ConnectionScheme {\n  /**\n   * Use HTTP request for connecting to host.\n   */\n  HTTP = 'HTTP',\n\n  /**\n   * Use HTTPS request for connecting to host.\n   */\n  HTTPS = 'HTTPS',\n}\n\nexport interface HttpHeader {\n  /**\n   * The HTTP Header name to be used\n   */\n  readonly name: string;\n\n  /**\n   * The HTTP header value to be set\n   */\n  readonly value: string;\n}\n\n/**\n * Options for `Probe.fromHttpGet()`.\n */\nexport interface HttpGetProbeOptions extends ProbeOptions {\n  /**\n   * The TCP port to use when sending the GET request.\n   *\n   * @default - defaults to `container.port`.\n   */\n  readonly port?: number;\n\n  /**\n   *  Scheme to use for connecting to the host (HTTP or HTTPS).\n   *\n   *  @default ConnectionScheme.HTTP\n   */\n  readonly scheme?: ConnectionScheme;\n\n  /**\n   * The host name to connect to on the container.\n   *\n   * @default - defaults to the pod IP\n   */\n  readonly host?: string;\n\n  /**\n   * Custom HTTP headers to set in the probe request. Note that HTTP allows repeated headers.\n   *\n   * @default - no custom headers are set\n   */\n  readonly httpHeaders?: HttpHeader[];\n}\n\n/**\n * Options for `Probe.fromCommand()`.\n */\nexport interface CommandProbeOptions extends ProbeOptions {\n\n}\n\n/**\n * Options for `Probe.fromTcpSocket()`.\n */\nexport interface TcpSocketProbeOptions extends ProbeOptions {\n  /**\n   * The TCP port to connect to on the container.\n   *\n   * @default - defaults to `container.port`.\n   */\n  readonly port?: number;\n\n  /**\n   * The host name to connect to on the container.\n   *\n   * @default - defaults to the pod IP\n   */\n  readonly host?: string;\n}\n\n/**\n * Options for `Probe.fromGrpc()`.\n */\nexport interface GrpcProbeOptions extends ProbeOptions {\n  /**\n   * The TCP port to connect to on the container.\n   *\n   * @default - defaults to `container.port`.\n   */\n  readonly port?: number;\n\n  /**\n   * Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n   *\n   * @default - If this is not specified, the default behavior is defined by gRPC.\n   */\n  readonly service?: string;\n}\n\n/**\n * Probe describes a health check to be performed against a container to\n * determine whether it is alive or ready to receive traffic.\n */\nexport class Probe {\n\n  /**\n   * Defines a probe based on an HTTP GET request to the IP address of the container.\n   *\n   * @param path The URL path to hit\n   * @param options Options\n   */\n  public static fromHttpGet(path: string, options: HttpGetProbeOptions = {}): Probe {\n    return new Probe(options, undefined, undefined, { path, ...options }, undefined);\n  }\n\n  /**\n   * Defines a probe based on a command which is executed within the container.\n   *\n   * @param command The command to execute\n   * @param options Options\n   */\n  public static fromCommand(command: string[], options: CommandProbeOptions = {}): Probe {\n    return new Probe(options, undefined, { command, ...options }, undefined, undefined);\n  }\n\n  /**\n   * Defines a probe based opening a connection to a TCP socket on the container.\n   *\n   * @param options Options\n   */\n  public static fromTcpSocket(options: TcpSocketProbeOptions = {}): Probe {\n    return new Probe(options, options, undefined, undefined, undefined);\n  }\n\n  /**\n   * Defines a probe based on a gRPC request to the container.\n   *\n   * @param options Options\n   */\n  public static fromGrpc(options: GrpcProbeOptions = {}): Probe {\n    return new Probe(options, undefined, undefined, undefined, options);\n  }\n\n  private constructor(\n    private readonly probeOptions: ProbeOptions,\n    private readonly tcpSocketOptions?: TcpSocketProbeOptions,\n    private readonly commandOptions?: { command: string[] } & ProbeOptions,\n    private readonly httpGetOptions?: { path: string } & HttpGetProbeOptions,\n    private readonly grpcOptions?: GrpcProbeOptions) {}\n\n  /**\n   * @internal\n   */\n  public _toKube(cont: container.Container): k8s.Probe {\n\n    const exec = this.commandOptions ? _action.Action.fromCommand(this.commandOptions.command) : undefined;\n    const httpGet = this.httpGetOptions ? _action.Action.fromHttpGet(cont, this.httpGetOptions.path, this.httpGetOptions) : undefined;\n    const tcpSocket = this.tcpSocketOptions ? _action.Action.fromTcpSocket(cont, this.tcpSocketOptions) : undefined;\n    const grpc = this.grpcOptions ? _action.Action.fromGrpc(cont, this.grpcOptions) : undefined;\n\n    return {\n      failureThreshold: this.probeOptions.failureThreshold ?? 3,\n      initialDelaySeconds: this.probeOptions.initialDelaySeconds ? this.probeOptions.initialDelaySeconds.toSeconds() : undefined,\n      periodSeconds: this.probeOptions.periodSeconds ? this.probeOptions.periodSeconds.toSeconds() : undefined,\n      successThreshold: this.probeOptions.successThreshold,\n      timeoutSeconds: this.probeOptions.timeoutSeconds ? this.probeOptions.timeoutSeconds.toSeconds() : undefined,\n      exec: exec,\n      httpGet,\n      tcpSocket,\n      grpc,\n    };\n  }\n}\n"]}