@intentius/terragucci 0.4.9 → 0.4.11

package/dist/report.schema.json

@@ -36,6 +36,7 @@
     "unit": { "enum": ["member", "instance"] },
     "units": { "type": "integer" },
     "totals": { "type": "object", "additionalProperties": { "type": "integer" } },
+    "totals_roots": { "type": "integer", "description": "How many roots totals counts a change of: each root whose plan creates, updates, replaces, deletes or forgets a resource, less a root the policy refused (minor 35)." },
     "groups": {
       "type": "array",
       "items": {
@@ -256,7 +257,8 @@
                 "data": { "type": "string" },
                 "outputs": { "enum": ["planned", "applied"] },
                 "unknown": { "type": "array", "items": { "type": "string" } },
-                "why": { "type": "string" }
+                "why": { "type": "string" },
+                "composed": { "const": true, "description": "A read of another root in the same composed run (waves.compose, minor 38): planned on the upstream's part of the composed plan, which the run applies before the resources that read it." }
               }
             }
           },
@@ -292,6 +294,15 @@
                 }
               }
             }
+          },
+          "composed": {
+            "type": "object",
+            "description": "A root in a composed run (waves.compose, minor 38): the wave whose run holds it and its module there. Its other fields come from its part of the composed plan; its plan_digest is that part's and binds nothing on its own.",
+            "required": ["wave", "module"],
+            "properties": {
+              "wave": { "type": "integer" },
+              "module": { "type": "string" }
+            }
           }
         }
       }
@@ -355,7 +366,7 @@
           },
           "state": { "enum": ["planned", "waiting", "applying", "applied", "refused", "failed"], "description": "Where the wave stands (minor 21): a tf-plan wave is planned; a tf-apply wave waiting, applying, applied, refused or failed." },
           "reads": { "type": "array", "items": { "type": "integer" }, "description": "The waves whose roots' state its roots read (minor 21)." },
-          "replans_after": { "type": "array", "items": { "type": "integer" }, "description": "A tf-plan wave whose plans read outputs known only once these waves apply: it plans again after they apply and waits for an approval of that plan; its review digest is null (minor 21)." },
+          "replans_after": { "type": "array", "items": { "type": "integer" }, "description": "A tf-plan wave whose plans read outputs known only once these waves apply: it plans again after they apply, and when that plan changes something its gate holds it for an approval of that plan under gate always or on-destructive, but not under gate never; its review digest is null (minor 21)." },
           "preview": {
             "type": "object",
             "required": ["pull_request", "units"],
@@ -375,7 +386,35 @@
               }
             }
           },
-          "environments": { "type": "array", "items": { "type": "string" }, "description": "The environments of environments: in terragucci.yml its roots are in, sorted (minor 33). Absent when none of its roots is in one." }
+          "environments": { "type": "array", "items": { "type": "string" }, "description": "The environments of environments: in terragucci.yml its roots are in, sorted (minor 33). Absent when none of its roots is in one." },
+          "composed": {
+            "type": "object",
+            "description": "The wave that carries a composed run (waves.compose, minor 38): one plan and one apply across several roots, each keeping its own state. The wave's roots list its own roots and the composed ones; its digests cover the composed plan as one member.",
+            "required": ["plan_digest", "members"],
+            "properties": {
+              "plan_digest": { "type": ["string", "null"], "description": "The composed plan's digest. Null when it failed to plan." },
+              "members": {
+                "type": "array",
+                "description": "Each root in the run, upstreams first.",
+                "items": {
+                  "type": "object",
+                  "required": ["root", "module"],
+                  "properties": {
+                    "root": { "type": "string" },
+                    "module": { "type": "string", "description": "Its address in the run, such as module.network." },
+                    "apply": { "enum": ["applied", "partial", "failed", "not-started", "no-changes"], "description": "tf-apply only: how its part of the apply ended, from the binary's apply events." },
+                    "changes": { "type": "object", "required": ["done", "planned"], "properties": { "done": { "type": "integer" }, "planned": { "type": "integer" } }, "description": "tf-apply only: how many of its planned changes completed." },
+                    "state": { "enum": ["written", "unchanged", "not-written"], "description": "tf-apply only: its state after the run." },
+                    "kept": { "type": "string", "description": "With not-written: where the state the run holds for it was kept." },
+                    "lock_held": { "type": "boolean", "description": "With not-written: whether its lock is still held." },
+                    "error": { "type": "string", "description": "Why the write failed, or the first error of its part of the apply." }
+                  }
+                }
+              },
+              "held_by_unknown": { "type": "array", "items": { "type": "string" }, "description": "The members that read a value of another member unknown at plan time: the gate holds the run under every gate but never." },
+              "error": { "type": "string", "description": "Why the run failed, when no member's own error says it." }
+            }
+          }
         }
       }
     },
@@ -423,6 +462,26 @@
         "overriders": { "type": "array", "items": { "type": "string" }, "description": "Who may override a denial, from policy.override at base (minor 10)." }
       }
     },
+    "compose": {
+      "type": "object",
+      "description": "waves.compose (minor 38), on a tf-plan and on a tf-apply wave's report when the run's config turns it on: the roots it covers, and the wave that composes them or why the change applies in waves.",
+      "required": ["roots", "max"],
+      "properties": {
+        "roots": { "type": "array", "items": { "type": "string" }, "description": "The roots the change reaches plus the roots they read, followed upstream, sorted." },
+        "max": { "type": "integer", "description": "waves.compose_max." },
+        "wave": { "type": "integer", "description": "The wave whose run composes them. Absent when the change applies in waves." },
+        "fallback": {
+          "type": "object",
+          "required": ["kind", "reason"],
+          "properties": {
+            "kind": { "type": "string" },
+            "root": { "type": "string" },
+            "reason": { "type": "string" }
+          },
+          "description": "Why the change applies in waves."
+        }
+      }
+    },
     "blast": {
       "description": "A tf-plan run's blast radius (minor 22): the roots whose plan changes a resource or an output, and every root of the repo that reads their state through terraform_remote_state (in a Terragrunt repo, every unit that depends on them through a dependency or dependencies block), followed through, nearest first. Absent when no root's plan changes anything, and on other stages.",
       "type": "object",
@@ -461,6 +520,7 @@
                   "properties": {
                     "root": { "type": "string" },
                     "address": { "type": "string", "description": "Its address in the root's configuration, with no instance key." },
+                    "depth": { "type": "integer", "minimum": 1, "description": "Its distance from the changed resource (minor 36): 1 when it refers to it, directly or through locals, variables and modules, and one more for each resource in between and each hop from a root's output into a root that reads it. Absent from a report before minor 36." },
                     "through": {
                       "type": "object",
                       "required": ["root", "output"],

package/dist/run.schema.json

@@ -43,6 +43,16 @@
                 "key": { "type": "string" }
               }
             }
+          },
+          "composed": {
+            "type": "object",
+            "description": "A root in a composed run (waves.compose): wave is the run's, own_wave the wave it would be in on its own, where the dependency order puts it.",
+            "required": ["wave", "module", "own_wave"],
+            "properties": {
+              "wave": { "type": "integer" },
+              "module": { "type": "string" },
+              "own_wave": { "type": "integer" }
+            }
           }
         }
       }
@@ -66,6 +76,8 @@
           "shares": { "type": "integer", "description": "A wave split across jobs: how many share jobs apply it." },
           "shares_applied": { "type": "array", "items": { "type": "integer" }, "description": "The shares that applied; the wave is applied once every share has." },
           "changed": { "type": "array", "items": { "type": "string" }, "description": "The roots whose plan in this wave changes a resource or an output: where the run's blast radius starts." },
+          "totals": { "type": "object", "additionalProperties": { "type": "integer" }, "description": "The wave's changes by action (create, update, replace, delete, read, no-op, forget), as its report's totals counts them, once it planned. Written by the job that plans the whole wave, not by a share of it." },
+          "totals_roots": { "type": "integer", "description": "How many of the wave's roots totals counts a change of: each root whose plan creates, updates, replaces, deletes or forgets a resource, less a root the policy refused." },
           "spans": {
             "type": "array",
             "description": "The wave's time, oldest first: each plan, each wait at its gate (no end while it waits) and each apply (no end while it applies). At most 24.",
@@ -102,6 +114,29 @@
               }
             }
           },
+          "composed": {
+            "type": "object",
+            "description": "The wave whose job runs a composed run (waves.compose): its roots, upstreams first; the composed plan's digest once planned; the roots that read a value unknown at plan time; and, once the apply ended, how each root's part of it ended and its state. A wave whose roots all moved into the run keeps its row with no roots.",
+            "required": ["roots"],
+            "properties": {
+              "roots": { "type": "array", "items": { "type": "string" } },
+              "digest": { "type": ["string", "null"] },
+              "unknown": { "type": "array", "items": { "type": "string" } },
+              "members": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "required": ["root", "module"],
+                  "properties": {
+                    "root": { "type": "string" },
+                    "module": { "type": "string" },
+                    "apply": { "enum": ["applied", "partial", "failed", "not-started", "no-changes"] },
+                    "state": { "enum": ["written", "unchanged", "not-written"] }
+                  }
+                }
+              }
+            }
+          },
           "updated": { "type": "string" }
         }
       }