terraconstructs 0.0.22 → 0.0.24

package/lib/aws/compute/autoscaling-common/interval-utils.js

@@ -0,0 +1,213 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-autoscaling-common/lib/interval-utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeIntervals = normalizeIntervals;
+exports.findAlarmThresholds = findAlarmThresholds;
+/**
+ * Normalize the given interval set to cover the complete number line and make sure it has at most one gap
+ */
+function normalizeIntervals(intervals, changesAreAbsolute) {
+    // Make intervals a complete numberline
+    const full = orderAndCompleteIntervals(intervals);
+    // Add 'undefined's in uncovered areas of the number line
+    makeGapsUndefined(full);
+    // In case of relative changes, treat 0-change also as 'undefined' (= no change action)
+    if (!changesAreAbsolute) {
+        makeZerosUndefined(full);
+    }
+    // Combine adjacent undefines and make sure there's at most one of them
+    combineUndefineds(full);
+    validateAtMostOneUndefined(full);
+    return full;
+}
+/**
+ * Completely order scaling intervals, making their lower and upper bounds concrete.
+ */
+function orderAndCompleteIntervals(intervals) {
+    if (intervals.length < 2) {
+        // throw new UnscopedValidationError(
+        throw new Error("Require at least 2 intervals");
+    }
+    for (const interval of intervals) {
+        if (interval.lower === undefined && interval.upper === undefined) {
+            // throw new UnscopedValidationError(
+            throw new Error(`Must supply at least one of 'upper' or 'lower', got: ${JSON.stringify(interval)}`);
+        }
+    }
+    // Make a copy
+    intervals = intervals.map((x) => ({ ...x }));
+    // Sort by whatever number we have for each interval
+    intervals.sort(comparatorFromKey((x) => x.lower ?? x.upper));
+    // Propagate boundaries until no more change
+    while (propagateBounds(intervals)) {
+        /* Repeat */
+    }
+    const lastIndex = intervals.length - 1;
+    // Validate that no intervals have undefined bounds now, which must mean they're complete.
+    if (intervals[0].lower === undefined) {
+        intervals[0] = { ...intervals[0], lower: 0 };
+    }
+    if (intervals[lastIndex].upper === undefined) {
+        intervals[lastIndex] = { ...intervals[lastIndex], upper: Infinity };
+    }
+    for (const interval of intervals) {
+        if (interval.lower === undefined || interval.upper === undefined) {
+            // throw new UnscopedValidationError(
+            throw new Error(`Could not determine the lower and upper bounds for ${JSON.stringify(interval)}`);
+        }
+    }
+    const completeIntervals = intervals;
+    // Validate that we have nonoverlapping intervals now.
+    for (let i = 0; i < completeIntervals.length - 1; i++) {
+        if (overlap(completeIntervals[i], completeIntervals[i + 1])) {
+            // throw new UnscopedValidationError(
+            throw new Error(`Two intervals overlap: ${JSON.stringify(completeIntervals[i])} and ${JSON.stringify(completeIntervals[i + 1])}`);
+        }
+    }
+    // Fill up the gaps
+    return completeIntervals;
+}
+/**
+ * Make the intervals cover the complete number line
+ *
+ * This entails adding intervals with an 'undefined' change to fill up the gaps.
+ *
+ * Since metrics have a halfopen interval, the first one will get a lower bound
+ * of 0, the last one will get an upper bound of +Infinity.
+ *
+ * In case of absolute adjustments, the lower number of the adjacent bound will
+ * be used, which means conservative change. In case of relative adjustments,
+ * we'll use relative adjusment 0 (which means no change).
+ */
+function makeGapsUndefined(intervals) {
+    // Add edge intervals if necessary, but only for relative adjustments. Since we're
+    // going to make scaling intervals extend all the way out to infinity on either side,
+    // the result is the same for absolute adjustments anyway.
+    if (intervals[0].lower !== 0) {
+        intervals.splice(0, 0, {
+            lower: 0,
+            upper: intervals[0].lower,
+            change: undefined,
+        });
+    }
+    if (last(intervals).upper !== Infinity) {
+        intervals.push({
+            lower: last(intervals).upper,
+            upper: Infinity,
+            change: undefined,
+        });
+    }
+    let i = 1;
+    while (i < intervals.length) {
+        if (intervals[i - 1].upper < intervals[i].lower) {
+            intervals.splice(i, 0, {
+                lower: intervals[i - 1].upper,
+                upper: intervals[i].lower,
+                change: undefined,
+            });
+        }
+        else {
+            i++;
+        }
+    }
+}
+/**
+ * Turn zero changes into undefined, in-place
+ */
+function makeZerosUndefined(intervals) {
+    for (let i = 0; i < intervals.length; ++i) {
+        const interval = intervals[i];
+        if (interval.change === 0) {
+            intervals[i] = { ...interval, change: undefined };
+        }
+    }
+}
+/**
+ * If there are adjacent "undefined" intervals, combine them
+ */
+function combineUndefineds(intervals) {
+    let i = 0;
+    while (i < intervals.length - 1) {
+        if (intervals[i].change === undefined &&
+            intervals[i + 1].change === undefined) {
+            intervals[i] = { ...intervals[i], upper: intervals[i + 1].upper };
+            intervals.splice(i + 1, 1);
+        }
+        else {
+            i++;
+        }
+    }
+}
+function validateAtMostOneUndefined(intervals) {
+    const undef = intervals.filter((x) => x.change === undefined);
+    if (undef.length > 1) {
+        // throw new UnscopedValidationError(
+        throw new Error(`Can have at most one no-change interval, got ${JSON.stringify(undef)}`);
+    }
+}
+function comparatorFromKey(keyFn) {
+    return (a, b) => {
+        const keyA = keyFn(a);
+        const keyB = keyFn(b);
+        if (keyA < keyB) {
+            return -1;
+        }
+        if (keyA === keyB) {
+            return 0;
+        }
+        return 1;
+    };
+}
+function propagateBounds(intervals) {
+    let ret = false;
+    // Propagate upper bounds upwards
+    for (let i = 0; i < intervals.length - 1; i++) {
+        if (intervals[i].upper !== undefined &&
+            intervals[i + 1].lower === undefined) {
+            intervals[i + 1] = { ...intervals[i + 1], lower: intervals[i].upper };
+            ret = true;
+        }
+    }
+    // Propagate lower bounds downwards
+    for (let i = intervals.length - 1; i >= 1; i--) {
+        if (intervals[i].lower !== undefined &&
+            intervals[i - 1].upper === undefined) {
+            intervals[i - 1] = { ...intervals[i - 1], upper: intervals[i].lower };
+            ret = true;
+        }
+    }
+    return ret;
+}
+/**
+ * Whether two intervals overlap
+ */
+function overlap(a, b) {
+    return a.lower < b.upper && a.upper > b.lower;
+}
+function last(xs) {
+    return xs[xs.length - 1];
+}
+/**
+ * Locate the intervals that should have the alarm thresholds, by index.
+ *
+ * Pick the intervals on either side of the singleton "undefined" interval, or
+ * pick the middle interval if there's no such interval.
+ */
+function findAlarmThresholds(intervals) {
+    const gapIndex = intervals.findIndex((x) => x.change === undefined);
+    if (gapIndex !== -1) {
+        return {
+            lowerAlarmIntervalIndex: gapIndex > 0 ? gapIndex - 1 : undefined,
+            upperAlarmIntervalIndex: gapIndex < intervals.length - 1 ? gapIndex + 1 : undefined,
+        };
+    }
+    if (intervals.length === 1) {
+        return { upperAlarmIntervalIndex: 0 };
+    }
+    const middleIndex = Math.floor(intervals.length / 2);
+    return {
+        lowerAlarmIntervalIndex: middleIndex - 1,
+        upperAlarmIntervalIndex: middleIndex,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interval-utils.js","sourceRoot":"","sources":["../../../../src/aws/compute/autoscaling-common/interval-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-autoscaling-common/lib/interval-utils.ts\n\nimport { ScalingInterval } from \"./types\";\n// TODO Adupt UnscopedValidationError is available, otherwise use standard Error\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import { ValidationError } from \"../../errors\";\n\nexport interface CompleteScalingInterval {\n  readonly lower: number;\n  readonly upper: number;\n  readonly change?: number;\n}\n\n/**\n * Normalize the given interval set to cover the complete number line and make sure it has at most one gap\n */\nexport function normalizeIntervals(\n  intervals: ScalingInterval[],\n  changesAreAbsolute: boolean,\n): CompleteScalingInterval[] {\n  // Make intervals a complete numberline\n  const full = orderAndCompleteIntervals(intervals);\n  // Add 'undefined's in uncovered areas of the number line\n  makeGapsUndefined(full);\n\n  // In case of relative changes, treat 0-change also as 'undefined' (= no change action)\n  if (!changesAreAbsolute) {\n    makeZerosUndefined(full);\n  }\n\n  // Combine adjacent undefines and make sure there's at most one of them\n  combineUndefineds(full);\n  validateAtMostOneUndefined(full);\n\n  return full;\n}\n\n/**\n * Completely order scaling intervals, making their lower and upper bounds concrete.\n */\nfunction orderAndCompleteIntervals(\n  intervals: ScalingInterval[],\n): CompleteScalingInterval[] {\n  if (intervals.length < 2) {\n    // throw new UnscopedValidationError(\n    throw new Error(\"Require at least 2 intervals\");\n  }\n\n  for (const interval of intervals) {\n    if (interval.lower === undefined && interval.upper === undefined) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        `Must supply at least one of 'upper' or 'lower', got: ${JSON.stringify(interval)}`,\n      );\n    }\n  }\n\n  // Make a copy\n  intervals = intervals.map((x) => ({ ...x }));\n\n  // Sort by whatever number we have for each interval\n  intervals.sort(comparatorFromKey((x: ScalingInterval) => x.lower ?? x.upper));\n\n  // Propagate boundaries until no more change\n  while (propagateBounds(intervals)) {\n    /* Repeat */\n  }\n\n  const lastIndex = intervals.length - 1;\n\n  // Validate that no intervals have undefined bounds now, which must mean they're complete.\n  if (intervals[0].lower === undefined) {\n    intervals[0] = { ...intervals[0], lower: 0 };\n  }\n  if (intervals[lastIndex].upper === undefined) {\n    intervals[lastIndex] = { ...intervals[lastIndex], upper: Infinity };\n  }\n  for (const interval of intervals) {\n    if (interval.lower === undefined || interval.upper === undefined) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        `Could not determine the lower and upper bounds for ${JSON.stringify(interval)}`,\n      );\n    }\n  }\n\n  const completeIntervals = intervals as CompleteScalingInterval[];\n\n  // Validate that we have nonoverlapping intervals now.\n  for (let i = 0; i < completeIntervals.length - 1; i++) {\n    if (overlap(completeIntervals[i], completeIntervals[i + 1])) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        `Two intervals overlap: ${JSON.stringify(completeIntervals[i])} and ${JSON.stringify(completeIntervals[i + 1])}`,\n      );\n    }\n  }\n\n  // Fill up the gaps\n\n  return completeIntervals;\n}\n\n/**\n * Make the intervals cover the complete number line\n *\n * This entails adding intervals with an 'undefined' change to fill up the gaps.\n *\n * Since metrics have a halfopen interval, the first one will get a lower bound\n * of 0, the last one will get an upper bound of +Infinity.\n *\n * In case of absolute adjustments, the lower number of the adjacent bound will\n * be used, which means conservative change. In case of relative adjustments,\n * we'll use relative adjusment 0 (which means no change).\n */\nfunction makeGapsUndefined(intervals: CompleteScalingInterval[]) {\n  // Add edge intervals if necessary, but only for relative adjustments. Since we're\n  // going to make scaling intervals extend all the way out to infinity on either side,\n  // the result is the same for absolute adjustments anyway.\n  if (intervals[0].lower !== 0) {\n    intervals.splice(0, 0, {\n      lower: 0,\n      upper: intervals[0].lower,\n      change: undefined,\n    });\n  }\n  if (last(intervals).upper !== Infinity) {\n    intervals.push({\n      lower: last(intervals).upper,\n      upper: Infinity,\n      change: undefined,\n    });\n  }\n\n  let i = 1;\n  while (i < intervals.length) {\n    if (intervals[i - 1].upper < intervals[i].lower) {\n      intervals.splice(i, 0, {\n        lower: intervals[i - 1].upper,\n        upper: intervals[i].lower,\n        change: undefined,\n      });\n    } else {\n      i++;\n    }\n  }\n}\n\n/**\n * Turn zero changes into undefined, in-place\n */\nfunction makeZerosUndefined(intervals: CompleteScalingInterval[]) {\n  for (let i = 0; i < intervals.length; ++i) {\n    const interval = intervals[i];\n    if (interval.change === 0) {\n      intervals[i] = { ...interval, change: undefined };\n    }\n  }\n}\n\n/**\n * If there are adjacent \"undefined\" intervals, combine them\n */\nfunction combineUndefineds(intervals: CompleteScalingInterval[]) {\n  let i = 0;\n  while (i < intervals.length - 1) {\n    if (\n      intervals[i].change === undefined &&\n      intervals[i + 1].change === undefined\n    ) {\n      intervals[i] = { ...intervals[i], upper: intervals[i + 1].upper };\n      intervals.splice(i + 1, 1);\n    } else {\n      i++;\n    }\n  }\n}\n\nfunction validateAtMostOneUndefined(intervals: CompleteScalingInterval[]) {\n  const undef = intervals.filter((x) => x.change === undefined);\n  if (undef.length > 1) {\n    // throw new UnscopedValidationError(\n    throw new Error(\n      `Can have at most one no-change interval, got ${JSON.stringify(undef)}`,\n    );\n  }\n}\n\nfunction comparatorFromKey<T, U>(keyFn: (x: T) => U) {\n  return (a: T, b: T) => {\n    const keyA = keyFn(a);\n    const keyB = keyFn(b);\n\n    if (keyA < keyB) {\n      return -1;\n    }\n    if (keyA === keyB) {\n      return 0;\n    }\n    return 1;\n  };\n}\n\nfunction propagateBounds(intervals: ScalingInterval[]) {\n  let ret = false;\n\n  // Propagate upper bounds upwards\n  for (let i = 0; i < intervals.length - 1; i++) {\n    if (\n      intervals[i].upper !== undefined &&\n      intervals[i + 1].lower === undefined\n    ) {\n      intervals[i + 1] = { ...intervals[i + 1], lower: intervals[i].upper };\n      ret = true;\n    }\n  }\n\n  // Propagate lower bounds downwards\n  for (let i = intervals.length - 1; i >= 1; i--) {\n    if (\n      intervals[i].lower !== undefined &&\n      intervals[i - 1].upper === undefined\n    ) {\n      intervals[i - 1] = { ...intervals[i - 1], upper: intervals[i].lower };\n      ret = true;\n    }\n  }\n\n  return ret;\n}\n\n/**\n * Whether two intervals overlap\n */\nfunction overlap(a: CompleteScalingInterval, b: CompleteScalingInterval) {\n  return a.lower < b.upper && a.upper > b.lower;\n}\n\nfunction last<T>(xs: T[]) {\n  return xs[xs.length - 1];\n}\n\nexport interface Alarms {\n  readonly lowerAlarmIntervalIndex?: number;\n  readonly upperAlarmIntervalIndex?: number;\n}\n\n/**\n * Locate the intervals that should have the alarm thresholds, by index.\n *\n * Pick the intervals on either side of the singleton \"undefined\" interval, or\n * pick the middle interval if there's no such interval.\n */\nexport function findAlarmThresholds(\n  intervals: CompleteScalingInterval[],\n): Alarms {\n  const gapIndex = intervals.findIndex((x) => x.change === undefined);\n\n  if (gapIndex !== -1) {\n    return {\n      lowerAlarmIntervalIndex: gapIndex > 0 ? gapIndex - 1 : undefined,\n      upperAlarmIntervalIndex:\n        gapIndex < intervals.length - 1 ? gapIndex + 1 : undefined,\n    };\n  }\n\n  if (intervals.length === 1) {\n    return { upperAlarmIntervalIndex: 0 };\n  }\n\n  const middleIndex = Math.floor(intervals.length / 2);\n\n  return {\n    lowerAlarmIntervalIndex: middleIndex - 1,\n    upperAlarmIntervalIndex: middleIndex,\n  };\n}\n"]}

package/lib/aws/compute/autoscaling-common/test-utils.d.ts

@@ -0,0 +1,21 @@
+import * as appscaling from ".";
+/**
+ * Arbitrary (valid) array of intervals
+ *
+ * There are many invalid combinations of interval arrays, so we have
+ * to be very specific about generating arrays that are valid. We do this
+ * by taking a full, valid interval schedule and progressively stripping parts
+ * away from it.
+ *
+ * Some of the changes may change its meaning, but we take care to never leave
+ * a schedule with insufficient information so that the parser will error out.
+ */
+export declare function generateArbitraryIntervals(mrng: IRandomGenerator): ArbitraryIntervals;
+export interface IRandomGenerator {
+    nextBoolean(): boolean;
+    nextInt(min: number, max: number): number;
+}
+export interface ArbitraryIntervals {
+    readonly absolute: boolean;
+    readonly intervals: appscaling.ScalingInterval[];
+}

package/lib/aws/compute/autoscaling-common/test-utils.js

@@ -0,0 +1,94 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-autoscaling-common/lib/test-utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArbitraryIntervals = generateArbitraryIntervals;
+/**
+ * Arbitrary (valid) array of intervals
+ *
+ * There are many invalid combinations of interval arrays, so we have
+ * to be very specific about generating arrays that are valid. We do this
+ * by taking a full, valid interval schedule and progressively stripping parts
+ * away from it.
+ *
+ * Some of the changes may change its meaning, but we take care to never leave
+ * a schedule with insufficient information so that the parser will error out.
+ */
+function generateArbitraryIntervals(mrng) {
+    const ret = new Array();
+    const absolute = mrng.nextBoolean();
+    // Ascending or descending scaling
+    const factor = (mrng.nextBoolean() ? 1 : -1) * (absolute ? 10 : 1);
+    const bias = absolute ? 50 : 0;
+    // Begin with a full schedule
+    ret.push({ lower: 0, upper: 10, change: -2 * factor + bias });
+    ret.push({ lower: 10, upper: 20, change: -1 * factor + bias });
+    ret.push({ lower: 20, upper: 60, change: 0 + bias });
+    ret.push({ lower: 60, upper: 80, change: 0 + bias });
+    ret.push({ lower: 80, upper: 90, change: 1 * factor + bias });
+    ret.push({ lower: 90, upper: Infinity, change: 2 * factor + bias });
+    // Take away parts from this. First we see if we do something to the 0-change alarms.
+    // The actions can be: remove it OR turn it into a regular change value.
+    const noChanges = ret.filter((x) => x.change === bias);
+    if (!absolute) {
+        if (mrng.nextBoolean()) {
+            if (mrng.nextBoolean()) {
+                ret.splice(ret.indexOf(noChanges[0]), 1);
+            }
+            else {
+                noChanges[0] = { ...noChanges[0], change: -1 * factor + bias };
+            }
+        }
+        if (mrng.nextBoolean()) {
+            if (mrng.nextBoolean()) {
+                ret.splice(ret.indexOf(noChanges[1]), 1);
+            }
+            else {
+                noChanges[1] = { ...noChanges[1], change: 1 * factor + bias };
+            }
+        }
+    }
+    else {
+        // In absolute mode both have to get the same treatment at the same time
+        // otherwise we'll end up with a timeline with two gaps
+        if (mrng.nextBoolean()) {
+            ret.splice(ret.indexOf(noChanges[0]), 1);
+            ret.splice(ret.indexOf(noChanges[1]), 1);
+        }
+        else {
+            noChanges[0] = { ...noChanges[0], change: -1 * factor + bias };
+            noChanges[1] = { ...noChanges[1], change: 1 * factor + bias };
+        }
+    }
+    // We might also take away either the bottom or the upper half
+    if (mrng.nextInt(0, 2) === 0) {
+        const signToStrip = mrng.nextBoolean() ? -1 : 1;
+        let ix = ret.findIndex((x) => Math.sign(x.change - bias) === signToStrip);
+        while (ix >= 0) {
+            ret.splice(ix, 1);
+            ix = ret.findIndex((x) => Math.sign(x.change - bias) === signToStrip);
+        }
+    }
+    // Then we're going to arbitrarily get rid of bounds in the most naive way possible
+    const iterations = mrng.nextInt(0, 10);
+    for (let iter = 0; iter < iterations; iter++) {
+        const i = mrng.nextInt(0, ret.length - 1);
+        if (mrng.nextBoolean()) {
+            // scrap lower bound
+            // okay if current interval has an upper bound AND the preceding interval has an upper bound
+            if (ret[i].upper !== undefined &&
+                (i === 0 || ret[i - 1].upper !== undefined)) {
+                ret[i] = { ...ret[i], lower: undefined };
+            }
+        }
+        else {
+            // scrap upper bound
+            // okay if current interval has a lower bound AND the succeeding interval has a lower bound
+            if (ret[i].lower !== undefined &&
+                (i === ret.length - 1 || ret[i + 1].lower !== undefined)) {
+                ret[i] = { ...ret[i], upper: undefined };
+            }
+        }
+    }
+    return { absolute, intervals: ret };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../../../../src/aws/compute/autoscaling-common/test-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-autoscaling-common/lib/test-utils.ts\n\nimport * as appscaling from \".\";\n\n/**\n * Arbitrary (valid) array of intervals\n *\n * There are many invalid combinations of interval arrays, so we have\n * to be very specific about generating arrays that are valid. We do this\n * by taking a full, valid interval schedule and progressively stripping parts\n * away from it.\n *\n * Some of the changes may change its meaning, but we take care to never leave\n * a schedule with insufficient information so that the parser will error out.\n */\nexport function generateArbitraryIntervals(\n  mrng: IRandomGenerator,\n): ArbitraryIntervals {\n  const ret = new Array<appscaling.ScalingInterval>();\n\n  const absolute = mrng.nextBoolean();\n\n  // Ascending or descending scaling\n  const factor = (mrng.nextBoolean() ? 1 : -1) * (absolute ? 10 : 1);\n  const bias = absolute ? 50 : 0;\n\n  // Begin with a full schedule\n  ret.push({ lower: 0, upper: 10, change: -2 * factor + bias });\n  ret.push({ lower: 10, upper: 20, change: -1 * factor + bias });\n  ret.push({ lower: 20, upper: 60, change: 0 + bias });\n  ret.push({ lower: 60, upper: 80, change: 0 + bias });\n  ret.push({ lower: 80, upper: 90, change: 1 * factor + bias });\n  ret.push({ lower: 90, upper: Infinity, change: 2 * factor + bias });\n\n  // Take away parts from this. First we see if we do something to the 0-change alarms.\n  // The actions can be: remove it OR turn it into a regular change value.\n  const noChanges = ret.filter((x) => x.change === bias);\n\n  if (!absolute) {\n    if (mrng.nextBoolean()) {\n      if (mrng.nextBoolean()) {\n        ret.splice(ret.indexOf(noChanges[0]), 1);\n      } else {\n        noChanges[0] = { ...noChanges[0], change: -1 * factor + bias };\n      }\n    }\n    if (mrng.nextBoolean()) {\n      if (mrng.nextBoolean()) {\n        ret.splice(ret.indexOf(noChanges[1]), 1);\n      } else {\n        noChanges[1] = { ...noChanges[1], change: 1 * factor + bias };\n      }\n    }\n  } else {\n    // In absolute mode both have to get the same treatment at the same time\n    // otherwise we'll end up with a timeline with two gaps\n    if (mrng.nextBoolean()) {\n      ret.splice(ret.indexOf(noChanges[0]), 1);\n      ret.splice(ret.indexOf(noChanges[1]), 1);\n    } else {\n      noChanges[0] = { ...noChanges[0], change: -1 * factor + bias };\n      noChanges[1] = { ...noChanges[1], change: 1 * factor + bias };\n    }\n  }\n\n  // We might also take away either the bottom or the upper half\n  if (mrng.nextInt(0, 2) === 0) {\n    const signToStrip = mrng.nextBoolean() ? -1 : 1;\n    let ix = ret.findIndex((x) => Math.sign(x.change - bias) === signToStrip);\n    while (ix >= 0) {\n      ret.splice(ix, 1);\n      ix = ret.findIndex((x) => Math.sign(x.change - bias) === signToStrip);\n    }\n  }\n\n  // Then we're going to arbitrarily get rid of bounds in the most naive way possible\n  const iterations = mrng.nextInt(0, 10);\n  for (let iter = 0; iter < iterations; iter++) {\n    const i = mrng.nextInt(0, ret.length - 1);\n    if (mrng.nextBoolean()) {\n      // scrap lower bound\n      // okay if current interval has an upper bound AND the preceding interval has an upper bound\n      if (\n        ret[i].upper !== undefined &&\n        (i === 0 || ret[i - 1].upper !== undefined)\n      ) {\n        ret[i] = { ...ret[i], lower: undefined };\n      }\n    } else {\n      // scrap upper bound\n      // okay if current interval has a lower bound AND the succeeding interval has a lower bound\n      if (\n        ret[i].lower !== undefined &&\n        (i === ret.length - 1 || ret[i + 1].lower !== undefined)\n      ) {\n        ret[i] = { ...ret[i], upper: undefined };\n      }\n    }\n  }\n\n  return { absolute, intervals: ret };\n}\n\nexport interface IRandomGenerator {\n  nextBoolean(): boolean;\n  nextInt(min: number, max: number): number;\n}\n\nexport interface ArbitraryIntervals {\n  readonly absolute: boolean;\n  readonly intervals: appscaling.ScalingInterval[];\n}\n"]}

package/lib/aws/compute/autoscaling-common/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A range of metric values in which to apply a certain scaling operation
+ */
+export interface ScalingInterval {
+    /**
+     * The lower bound of the interval.
+     *
+     * The scaling adjustment will be applied if the metric is higher than this value.
+     *
+     * @default Threshold automatically derived from neighbouring intervals
+     */
+    readonly lower?: number;
+    /**
+     * The upper bound of the interval.
+     *
+     * The scaling adjustment will be applied if the metric is lower than this value.
+     *
+     * @default Threshold automatically derived from neighbouring intervals
+     */
+    readonly upper?: number;
+    /**
+     * The capacity adjustment to apply in this interval
+     *
+     * The number is interpreted differently based on AdjustmentType:
+     *
+     * - ChangeInCapacity: add the adjustment to the current capacity.
+     *  The number can be positive or negative.
+     * - PercentChangeInCapacity: add or remove the given percentage of the current
+     *   capacity to itself. The number can be in the range [-100..100].
+     * - ExactCapacity: set the capacity to this number. The number must
+     *   be positive.
+     */
+    readonly change: number;
+}

package/lib/aws/compute/autoscaling-common/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL2NvbXB1dGUvYXV0b3NjYWxpbmctY29tbW9uL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgcmFuZ2Ugb2YgbWV0cmljIHZhbHVlcyBpbiB3aGljaCB0byBhcHBseSBhIGNlcnRhaW4gc2NhbGluZyBvcGVyYXRpb25cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTY2FsaW5nSW50ZXJ2YWwge1xuICAvKipcbiAgICogVGhlIGxvd2VyIGJvdW5kIG9mIHRoZSBpbnRlcnZhbC5cbiAgICpcbiAgICogVGhlIHNjYWxpbmcgYWRqdXN0bWVudCB3aWxsIGJlIGFwcGxpZWQgaWYgdGhlIG1ldHJpYyBpcyBoaWdoZXIgdGhhbiB0aGlzIHZhbHVlLlxuICAgKlxuICAgKiBAZGVmYXVsdCBUaHJlc2hvbGQgYXV0b21hdGljYWxseSBkZXJpdmVkIGZyb20gbmVpZ2hib3VyaW5nIGludGVydmFsc1xuICAgKi9cbiAgcmVhZG9ubHkgbG93ZXI/OiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSB1cHBlciBib3VuZCBvZiB0aGUgaW50ZXJ2YWwuXG4gICAqXG4gICAqIFRoZSBzY2FsaW5nIGFkanVzdG1lbnQgd2lsbCBiZSBhcHBsaWVkIGlmIHRoZSBtZXRyaWMgaXMgbG93ZXIgdGhhbiB0aGlzIHZhbHVlLlxuICAgKlxuICAgKiBAZGVmYXVsdCBUaHJlc2hvbGQgYXV0b21hdGljYWxseSBkZXJpdmVkIGZyb20gbmVpZ2hib3VyaW5nIGludGVydmFsc1xuICAgKi9cbiAgcmVhZG9ubHkgdXBwZXI/OiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSBjYXBhY2l0eSBhZGp1c3RtZW50IHRvIGFwcGx5IGluIHRoaXMgaW50ZXJ2YWxcbiAgICpcbiAgICogVGhlIG51bWJlciBpcyBpbnRlcnByZXRlZCBkaWZmZXJlbnRseSBiYXNlZCBvbiBBZGp1c3RtZW50VHlwZTpcbiAgICpcbiAgICogLSBDaGFuZ2VJbkNhcGFjaXR5OiBhZGQgdGhlIGFkanVzdG1lbnQgdG8gdGhlIGN1cnJlbnQgY2FwYWNpdHkuXG4gICAqICBUaGUgbnVtYmVyIGNhbiBiZSBwb3NpdGl2ZSBvciBuZWdhdGl2ZS5cbiAgICogLSBQZXJjZW50Q2hhbmdlSW5DYXBhY2l0eTogYWRkIG9yIHJlbW92ZSB0aGUgZ2l2ZW4gcGVyY2VudGFnZSBvZiB0aGUgY3VycmVudFxuICAgKiAgIGNhcGFjaXR5IHRvIGl0c2VsZi4gVGhlIG51bWJlciBjYW4gYmUgaW4gdGhlIHJhbmdlIFstMTAwLi4xMDBdLlxuICAgKiAtIEV4YWN0Q2FwYWNpdHk6IHNldCB0aGUgY2FwYWNpdHkgdG8gdGhpcyBudW1iZXIuIFRoZSBudW1iZXIgbXVzdFxuICAgKiAgIGJlIHBvc2l0aXZlLlxuICAgKi9cbiAgcmVhZG9ubHkgY2hhbmdlOiBudW1iZXI7XG59XG4iXX0=

package/lib/aws/compute/base-scalable-attribute.d.ts

@@ -0,0 +1,74 @@
+import { Construct } from "constructs";
+import { ScalingSchedule, ServiceNamespace } from "./scalable-target";
+import { BasicStepScalingPolicyProps } from "./step-scaling-policy";
+import { BasicTargetTrackingScalingPolicyProps } from "./target-tracking-scaling-policy";
+import * as iam from "../iam";
+/**
+ * Properties for a ScalableTableAttribute
+ */
+export interface BaseScalableAttributeProps extends EnableScalingProps {
+    /**
+     * Service namespace of the scalable attribute
+     */
+    readonly serviceNamespace: ServiceNamespace;
+    /**
+     * Resource ID of the attribute
+     */
+    readonly resourceId: string;
+    /**
+     * Scalable dimension of the attribute
+     */
+    readonly dimension: string;
+    /**
+     * Role to use for scaling
+     *
+     * @default A role is automatically created
+     */
+    readonly role?: iam.IRole;
+}
+/**
+ * Represent an attribute for which autoscaling can be configured
+ *
+ * This class is basically a light wrapper around ScalableTarget, but with
+ * all methods protected instead of public so they can be selectively
+ * exposed and/or more specific versions of them can be exposed by derived
+ * classes for individual services support autoscaling.
+ *
+ * Typical use cases:
+ *
+ * - Hide away the PredefinedMetric enum for target tracking policies.
+ * - Don't expose all scaling methods (for example Dynamo tables don't support
+ *   Step Scaling, so the Dynamo subclass won't expose this method).
+ */
+export declare abstract class BaseScalableAttribute extends Construct {
+    protected readonly props: BaseScalableAttributeProps;
+    private target;
+    constructor(scope: Construct, id: string, props: BaseScalableAttributeProps);
+    /**
+     * Scale out or in based on time
+     */
+    protected doScaleOnSchedule(id: string, props: ScalingSchedule): void;
+    /**
+     * Scale out or in based on a metric value
+     */
+    protected doScaleOnMetric(id: string, props: BasicStepScalingPolicyProps): void;
+    /**
+     * Scale out or in in order to keep a metric around a target value
+     */
+    protected doScaleToTrackMetric(id: string, props: BasicTargetTrackingScalingPolicyProps): void;
+}
+/**
+ * Properties for enabling Application Auto Scaling
+ */
+export interface EnableScalingProps {
+    /**
+     * Minimum capacity to scale to
+     *
+     * @default 1
+     */
+    readonly minCapacity?: number;
+    /**
+     * Maximum capacity to scale to
+     */
+    readonly maxCapacity: number;
+}

package/lib/aws/compute/base-scalable-attribute.js

@@ -0,0 +1,58 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseScalableAttribute = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/base-scalable-attribute.ts
+const constructs_1 = require("constructs");
+const scalable_target_1 = require("./scalable-target");
+/**
+ * Represent an attribute for which autoscaling can be configured
+ *
+ * This class is basically a light wrapper around ScalableTarget, but with
+ * all methods protected instead of public so they can be selectively
+ * exposed and/or more specific versions of them can be exposed by derived
+ * classes for individual services support autoscaling.
+ *
+ * Typical use cases:
+ *
+ * - Hide away the PredefinedMetric enum for target tracking policies.
+ * - Don't expose all scaling methods (for example Dynamo tables don't support
+ *   Step Scaling, so the Dynamo subclass won't expose this method).
+ */
+class BaseScalableAttribute extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.target = new scalable_target_1.ScalableTarget(this, "Target", {
+            serviceNamespace: this.props.serviceNamespace,
+            scalableDimension: this.props.dimension,
+            resourceId: this.props.resourceId,
+            role: this.props.role,
+            minCapacity: props.minCapacity ?? 1,
+            maxCapacity: props.maxCapacity,
+        });
+    }
+    /**
+     * Scale out or in based on time
+     */
+    doScaleOnSchedule(id, props) {
+        this.target.scaleOnSchedule(id, props);
+    }
+    /**
+     * Scale out or in based on a metric value
+     */
+    doScaleOnMetric(id, props) {
+        this.target.scaleOnMetric(id, props);
+    }
+    /**
+     * Scale out or in in order to keep a metric around a target value
+     */
+    doScaleToTrackMetric(id, props) {
+        this.target.scaleToTrackMetric(id, props);
+    }
+}
+exports.BaseScalableAttribute = BaseScalableAttribute;
+_a = JSII_RTTI_SYMBOL_1;
+BaseScalableAttribute[_a] = { fqn: "terraconstructs.aws.compute.BaseScalableAttribute", version: "0.0.24" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/bastion-host.js

@@ -110,5 +110,5 @@ class BastionHostLinux extends aws_construct_1.AwsConstructBase {
 }
 exports.BastionHostLinux = BastionHostLinux;
 _a = JSII_RTTI_SYMBOL_1;
-BastionHostLinux[_a] = { fqn: "terraconstructs.aws.compute.BastionHostLinux", version: "0.0.22" };
+BastionHostLinux[_a] = { fqn: "terraconstructs.aws.compute.BastionHostLinux", version: "0.0.24" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bastion-host.js","sourceRoot":"","sources":["../../../src/aws/compute/bastion-host.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/bastion-host.ts\n\nimport { TerraformOutput } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  InstanceArchitecture,\n  InstanceClass,\n  InstanceSize,\n  InstanceType,\n} from \".\";\n// import { CloudFormationInit } from \"./cfn-init\";\nimport { Connections } from \"./connections\";\nimport {\n  // ApplyCloudFormationInitOptions,\n  IInstance,\n  Instance,\n  InstanceOutputs,\n} from \"./instance\";\nimport {\n  AmazonLinuxCpuType,\n  IMachineImage,\n  MachineImage,\n} from \"./machine-image\";\nimport { IPeer } from \"./peer\";\nimport { Port } from \"./port\";\nimport { ISecurityGroup } from \"./security-group\";\nimport { BlockDevice } from \"./volume\";\nimport { IVpc, SubnetSelection } from \"./vpc\";\nimport { AwsConstructBase } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { IPrincipal, IRole, PolicyStatement } from \"../iam\";\n\n/**\n * Properties of the bastion host\n *\n *\n */\nexport interface BastionHostLinuxProps {\n  /**\n   * In which AZ to place the instance within the VPC\n   *\n   * @default - Random zone.\n   */\n  readonly availabilityZone?: string;\n\n  /**\n   * VPC to launch the instance in.\n   */\n  readonly vpc: IVpc;\n\n  /**\n   * The name of the instance\n   *\n   * @default 'BastionHost'\n   */\n  readonly instanceName?: string;\n\n  /**\n   * Select the subnets to run the bastion host in.\n   * Set this to PUBLIC if you need to connect to this instance via the internet and cannot use SSM.\n   * You have to allow port 22 manually by using the connections field\n   *\n   * @default - private subnets of the supplied VPC\n   */\n  readonly subnetSelection?: SubnetSelection;\n\n  /**\n   * Security Group to assign to this instance\n   *\n   * @default - create new security group with no inbound and all outbound traffic allowed\n   */\n  readonly securityGroup?: ISecurityGroup;\n\n  /**\n   * Type of instance to launch\n   * @default 't3.nano'\n   */\n  readonly instanceType?: InstanceType;\n\n  /**\n   * The machine image to use, assumed to have SSM Agent preinstalled.\n   *\n   * @default - An Amazon Linux 2023 image if the `@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault` feature flag is enabled. Otherwise, an Amazon Linux 2 image. In both cases, the image is kept up-to-date automatically (the instance\n   * may be replaced on every deployment) and already has SSM Agent installed.\n   */\n  readonly machineImage?: IMachineImage;\n\n  /**\n   * Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.\n   *\n   * Each instance that is launched has an associated root device volume,\n   * either an Amazon EBS volume or an instance store volume.\n   * You can use block device mappings to specify additional EBS volumes or\n   * instance store volumes to attach to an instance when it is launched.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html\n   *\n   * @default - Uses the block device mapping of the AMI\n   */\n  readonly blockDevices?: BlockDevice[];\n\n  // /**\n  //  * Apply the given CloudFormation Init configuration to the instance at startup\n  //  *\n  //  * @default - no CloudFormation init\n  //  */\n  // readonly init?: CloudFormationInit;\n\n  // /**\n  //  * Use the given options for applying CloudFormation Init\n  //  *\n  //  * Describes the configsets to use and the timeout to wait\n  //  *\n  //  * @default - default options\n  //  */\n  // readonly initOptions?: ApplyCloudFormationInitOptions;\n\n  /**\n   * Whether IMDSv2 should be required on this instance\n   *\n   * @default - false\n   */\n  readonly requireImdsv2?: boolean;\n\n  /**\n   * Determines whether changes to the UserData will force instance replacement.\n   *\n   * Depending on the EC2 instance type, modifying the UserData may either restart\n   * or replace the instance:\n   *\n   * - Instance store-backed instances are replaced.\n   * - EBS-backed instances are restarted.\n   *\n   * Note that by default, restarting does not execute the updated UserData, so an alternative\n   * mechanism is needed to ensure the instance re-executes the UserData.\n   *\n   * When set to `true`, the instance's Logical ID will depend on the UserData, causing\n   * CloudFormation to replace the instance if the UserData changes.\n   *\n   * @default - `true` if `initOptions` is specified, otherwise `false`.\n   */\n  readonly userDataCausesReplacement?: boolean;\n}\n\n/**\n * This creates a linux bastion host you can use to connect to other instances or services in your VPC.\n * The recommended way to connect to the bastion host is by using AWS Systems Manager Session Manager.\n *\n * The operating system is Amazon Linux 2 with the latest SSM agent installed\n *\n * You can also configure this bastion host to allow connections via SSH\n *\n *\n * @resource aws_instance\n */\nexport class BastionHostLinux extends AwsConstructBase implements IInstance {\n  public get instanceOutputs(): InstanceOutputs {\n    return {\n      instanceId: this.instanceId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.instanceOutputs;\n  }\n\n  public readonly stack: AwsStack;\n\n  /**\n   * Allows specify security group connections for the instance.\n   */\n  public readonly connections: Connections;\n\n  /**\n   * The IAM role assumed by the instance.\n   */\n  public readonly role: IRole;\n\n  /**\n   * The principal to grant permissions to\n   */\n  public readonly grantPrincipal: IPrincipal;\n\n  /**\n   * The underlying instance resource\n   */\n  public readonly instance: Instance;\n\n  /**\n   * @attribute\n   */\n  public readonly instanceId: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instanceAvailabilityZone: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePrivateDnsName: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePrivateIp: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePublicDnsName: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePublicIp: string;\n\n  constructor(scope: Construct, id: string, props: BastionHostLinuxProps) {\n    super(scope, id);\n    this.stack = AwsStack.ofAwsConstruct(scope);\n    const instanceType =\n      props.instanceType ??\n      InstanceType.of(InstanceClass.T3, InstanceSize.NANO);\n    this.instance = new Instance(this, \"Resource\", {\n      vpc: props.vpc,\n      availabilityZone: props.availabilityZone,\n      securityGroup: props.securityGroup,\n      instanceName: props.instanceName ?? \"BastionHost\",\n      instanceType,\n      machineImage: this.getMachineImage(this, instanceType, props),\n      vpcSubnets: props.subnetSelection ?? {},\n      blockDevices: props.blockDevices ?? undefined,\n      // init: props.init,\n      // initOptions: props.initOptions,\n      requireImdsv2: props.requireImdsv2 ?? false,\n      userDataCausesReplacement: props.userDataCausesReplacement,\n    });\n    this.instance.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          \"ssmmessages:*\",\n          \"ssm:UpdateInstanceInformation\",\n          \"ec2messages:*\",\n        ],\n        resources: [\"*\"],\n      }),\n    );\n    this.connections = this.instance.connections;\n    this.role = this.instance.role;\n    this.grantPrincipal = this.instance.role;\n    this.instanceId = this.instance.instanceId;\n    this.instancePrivateIp = this.instance.instancePrivateIp;\n    this.instanceAvailabilityZone = this.instance.instanceAvailabilityZone;\n    this.instancePrivateDnsName = this.instance.instancePrivateDnsName;\n    this.instancePublicIp = this.instance.instancePublicIp;\n    this.instancePublicDnsName = this.instance.instancePublicDnsName;\n\n    new TerraformOutput(this, \"BastionHostId\", {\n      description:\n        \"Instance ID of the bastion host. Use this to connect via SSM Session Manager\",\n      value: this.instanceId,\n    });\n  }\n\n  /**\n   * Returns the AmazonLinuxCpuType corresponding to the given instance architecture\n   * @param architecture the instance architecture value to convert\n   */\n  private toAmazonLinuxCpuType(\n    architecture: InstanceArchitecture,\n  ): AmazonLinuxCpuType {\n    if (architecture === InstanceArchitecture.ARM_64) {\n      return AmazonLinuxCpuType.ARM_64;\n    } else if (architecture === InstanceArchitecture.X86_64) {\n      return AmazonLinuxCpuType.X86_64;\n    }\n\n    throw new Error(`Unsupported instance architecture '${architecture}'`);\n  }\n\n  /**\n   * Allow SSH access from the given peer or peers\n   *\n   * Necessary if you want to connect to the instance using ssh. If not\n   * called, you should use SSM Session Manager to connect to the instance.\n   */\n  public allowSshAccessFrom(...peer: IPeer[]): void {\n    peer.forEach((p) => {\n      this.connections.allowFrom(p, Port.tcp(22), \"SSH access\");\n    });\n  }\n\n  /**\n   * Returns the machine image to use for the bastion host, respecting the feature flag\n   * to default to Amazon Linux 2023 if enabled, otherwise defaulting to Amazon Linux 2.\n   */\n  private getMachineImage(\n    _scope: Construct,\n    instanceType: InstanceType,\n    props: BastionHostLinuxProps,\n  ): IMachineImage {\n    const defaultMachineImage = MachineImage.latestAmazonLinux2023({\n      cpuType: this.toAmazonLinuxCpuType(instanceType.architecture),\n    });\n    return props.machineImage ?? defaultMachineImage;\n  }\n}\n"]}

package/lib/aws/compute/chain.js

@@ -64,5 +64,5 @@ class Chain {
 }
 exports.Chain = Chain;
 _a = JSII_RTTI_SYMBOL_1;
-Chain[_a] = { fqn: "terraconstructs.aws.compute.Chain", version: "0.0.22" };
+Chain[_a] = { fqn: "terraconstructs.aws.compute.Chain", version: "0.0.24" };
 //# sourceMappingURL=data:application/json;base64,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