Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
67 changes: 67 additions & 0 deletions .github/actions/agent/assert-trigger-publication/action.yml
Original file line number Diff line number Diff line change
@@ -0,0 +1,67 @@
name: Assert durable Agent trigger acceptance
description: Validate Provider publications in the installed Agent journal.

inputs:
container-name:
description: Fedora container running the installed Agent.
required: true
provider-instance-id:
description: Provider identity whose durable publications are expected.
required: true
expected-triggers:
description: Space-separated trigger identifiers expected in the journal.
required: true
evidence-name:
description: Safe basename for the resulting JSON evidence.
required: true
evidence-directory:
description: Host directory receiving validated journal evidence.
required: true
timeout-seconds:
description: Maximum time to wait for the exact publication set.
required: false
default: "60"

runs:
using: composite
steps:
- name: Assert durable trigger publications
shell: bash
env:
ACTION_PATH: ${{ github.action_path }}
CONTAINER_NAME: ${{ inputs.container-name }}
EVIDENCE_DIRECTORY: ${{ inputs.evidence-directory }}
EVIDENCE_NAME: ${{ inputs.evidence-name }}
EXPECTED_TRIGGERS: ${{ inputs.expected-triggers }}
PROVIDER_INSTANCE_ID: ${{ inputs.provider-instance-id }}
TIMEOUT_SECONDS: ${{ inputs.timeout-seconds }}
run: |
set -euo pipefail
if [[ ! "${EVIDENCE_NAME}" =~ ^[a-z][a-z0-9-]{0,40}$ \
|| ! "${TIMEOUT_SECONDS}" =~ ^[1-9][0-9]*$ ]]; then
printf 'Trigger assertion inputs are invalid.\n' >&2
exit 2
fi
read -r -a expected_triggers <<< "${EXPECTED_TRIGGERS}"
if (( ${#expected_triggers[@]} == 0 )); then
printf 'At least one expected trigger is required.\n' >&2
exit 2
fi

mkdir -p "${EVIDENCE_DIRECTORY}"
verifier_directory=/opt/stateforge-agent-tests/trigger-publication
verifier="${verifier_directory}/assert.py"
docker exec "${CONTAINER_NAME}" mkdir -p "${verifier_directory}"
docker cp "${ACTION_PATH}/assert.py" \
"${CONTAINER_NAME}:${verifier}"

arguments=()
for identifier in "${expected_triggers[@]}"; do
arguments+=(--expected-trigger "${identifier}")
done
docker exec "${CONTAINER_NAME}" /usr/bin/python3 "${verifier}" \
--database /var/lib/stateforge-agent/journal/agent.db \
--provider-instance-id "${PROVIDER_INSTANCE_ID}" \
--timeout-seconds "${TIMEOUT_SECONDS}" \
"${arguments[@]}" \
> "${EVIDENCE_DIRECTORY}/${EVIDENCE_NAME}.json"
133 changes: 133 additions & 0 deletions .github/actions/agent/assert-trigger-publication/assert.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,133 @@
"""Validate durable Trigger Publication evidence in an installed Agent."""

from __future__ import annotations

import argparse
import hashlib
import json
import sqlite3
import sys
import time
from pathlib import Path
from uuid import UUID

from stateforge_protocol.sfp.trigger_publication.v1 import (
trigger_publication_pb2,
validation,
)


def _arguments() -> argparse.Namespace:
parser = argparse.ArgumentParser()
parser.add_argument("--database", type=Path, required=True)
parser.add_argument("--provider-instance-id", type=UUID, required=True)
parser.add_argument("--expected-trigger", action="append", required=True)
parser.add_argument("--timeout-seconds", type=int, required=True)
return parser.parse_args()


def _rows(
database: Path,
provider_instance_id: UUID,
) -> list[sqlite3.Row]:
connection = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
connection.row_factory = sqlite3.Row
try:
return list(
connection.execute(
"""
SELECT publication_id, content_fingerprint, publication,
trigger_identifier, observed_at, endpoint_generation,
session_id, manifest_revision, accepted_at,
forwarding_state
FROM trigger_publications
WHERE provider_instance_id = ?
ORDER BY accepted_at, publication_id
""",
(str(provider_instance_id),),
)
)
finally:
connection.close()


def _validated_evidence(
rows: list[sqlite3.Row],
expected_triggers: list[str],
) -> dict[str, object]:
actual = [str(row["trigger_identifier"]) for row in rows]
if sorted(actual) != sorted(expected_triggers):
raise ValueError(
"Durable publications do not match the expected trigger set"
)

publications: list[dict[str, object]] = []
for row in rows:
publication = trigger_publication_pb2.TriggerPublication.FromString(
row["publication"]
)
validation.validate_trigger_publication(publication)
fingerprint = validation.compute_publication_content_fingerprint(
publication
)
if publication.publication_id != row["publication_id"]:
raise ValueError("Stored publication identity is inconsistent")
if publication.trigger_identifier != row["trigger_identifier"]:
raise ValueError("Stored trigger identifier is inconsistent")
if fingerprint != row["content_fingerprint"]:
raise ValueError("Stored publication fingerprint is inconsistent")
if row["forwarding_state"] != "pending":
raise ValueError(
"Accepted publication lost pending responsibility"
)
publications.append(
{
"accepted_at": row["accepted_at"],
"content_fingerprint": fingerprint,
"endpoint_generation": row["endpoint_generation"],
"forwarding_state": row["forwarding_state"],
"manifest_revision": row["manifest_revision"],
"observed_at": row["observed_at"],
"publication_id": publication.publication_id,
"session_id_sha256": hashlib.sha256(
row["session_id"].encode()
).hexdigest(),
"trigger_identifier": publication.trigger_identifier,
}
)
return {
"publication_count": len(publications),
"publications": publications,
}


def main() -> None:
"""Wait for, validate, and emit the expected durable evidence."""
arguments = _arguments()
if arguments.timeout_seconds <= 0:
raise ValueError("timeout-seconds must be positive")
deadline = time.monotonic() + arguments.timeout_seconds
last_error: Exception | None = None
while time.monotonic() < deadline:
try:
evidence = _validated_evidence(
_rows(
arguments.database,
arguments.provider_instance_id,
),
arguments.expected_trigger,
)
except (OSError, sqlite3.Error, ValueError) as error:
last_error = error
time.sleep(0.25)
continue
sys.stdout.write(json.dumps(evidence, indent=2, sort_keys=True))
sys.stdout.write("\n")
return
raise RuntimeError(
"Installed Agent did not retain the expected trigger publications"
) from last_error


if __name__ == "__main__":
main()
Loading
Loading