mirror of
https://github.com/kerberos-io/agent.git
synced 2026-11-18 22:20:50 +00:00
Compare commits
12
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
54b10967b2 | ||
|
|
7b95de7c10 | ||
|
|
29537da6e8 | ||
|
|
69ac25396d | ||
|
|
04beb83540 | ||
|
|
85dcb841e2 | ||
|
|
322ac7d7c9 | ||
|
|
e6f0c068da | ||
|
|
e3acd64a57 | ||
|
|
9553b1b4b9 | ||
|
|
f6ce5e0846 | ||
|
|
024bb0abf9 |
@@ -0,0 +1,42 @@
|
||||
# Only application sources are needed by the production build.
|
||||
**
|
||||
!Dockerfile
|
||||
!machinery/
|
||||
!machinery/**
|
||||
!ui/
|
||||
!ui/**
|
||||
!deployments/
|
||||
deployments/*
|
||||
!deployments/docker/
|
||||
deployments/docker/*
|
||||
!deployments/docker/assemble-rootfs.sh
|
||||
|
||||
**/.git
|
||||
**/.env
|
||||
**/.env.*
|
||||
**/.git-credentials
|
||||
**/.netrc
|
||||
**/.npmrc
|
||||
**/.yarnrc.yml
|
||||
**/.aws
|
||||
**/.ssh
|
||||
**/.kube
|
||||
**/node_modules
|
||||
**/.DS_Store
|
||||
**/*.test
|
||||
**/*.pprof
|
||||
**/coverage.out
|
||||
machinery/main
|
||||
machinery/vendor
|
||||
machinery/go.work
|
||||
machinery/go.work.sum
|
||||
machinery/www
|
||||
machinery/data/**
|
||||
!machinery/data/config/
|
||||
!machinery/data/config/config.json
|
||||
!machinery/data/config/user.json
|
||||
!machinery/data/test-480p.mp4
|
||||
ui/build
|
||||
ui/coverage
|
||||
ui/.npmrc
|
||||
ui/.yarnrc
|
||||
@@ -0,0 +1,30 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Validate BuildKit provenance and retain resolved base-image materials."""
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
import re
|
||||
import sys
|
||||
|
||||
|
||||
def materials(value):
|
||||
if isinstance(value, dict):
|
||||
if "uri" in value and value["uri"].startswith(("pkg:docker/", "docker-image://")):
|
||||
digest = value.get("digest", {}).get("sha256", "")
|
||||
if not re.fullmatch(r"[a-f0-9]{64}", digest):
|
||||
raise ValueError(f"Missing base-image digest: {value['uri']}")
|
||||
yield value
|
||||
for child in value.values():
|
||||
yield from materials(child)
|
||||
elif isinstance(value, list):
|
||||
for child in value:
|
||||
yield from materials(child)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
directory = Path(sys.argv[1])
|
||||
provenance = json.loads((directory / "provenance.json").read_text())
|
||||
bases = list(materials(provenance))
|
||||
if not bases:
|
||||
raise SystemExit("Missing provenance/base-image materials")
|
||||
(directory / "base-image-digests.json").write_text(json.dumps(bases, indent=2) + "\n")
|
||||
@@ -0,0 +1,242 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Fail-closed source/application and image scans with redacted evidence."""
|
||||
|
||||
import argparse
|
||||
from datetime import datetime, timezone
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
|
||||
def secret_identity(target, finding):
|
||||
return (target, finding.get("RuleID"), finding.get("Category"),
|
||||
finding.get("Severity"), finding.get("StartLine"), finding.get("EndLine"))
|
||||
|
||||
|
||||
def approve_shared_key(report, source_root, policy, now=None):
|
||||
"""Bind the one reviewed exception to an unchanged file and exact finding."""
|
||||
now = now or datetime.now(timezone.utc)
|
||||
records = policy.get("exceptions")
|
||||
if not isinstance(records, list) or len(records) != 1:
|
||||
raise ValueError("Exactly one shared-key exception record is required")
|
||||
record = records[0]
|
||||
if not isinstance(record, dict) or record.get("id") != "shared-recording-signing-key":
|
||||
raise ValueError("Unexpected scan exception")
|
||||
if record.get("status") != "approved" or not all(
|
||||
isinstance(record.get(key), str) and record[key].strip()
|
||||
for key in ("owner", "approved_by", "reason", "approval_url", "expires")
|
||||
):
|
||||
raise ValueError("Shared-key exception lacks approval/owner/reason/evidence/expiry")
|
||||
if record["approval_url"] != "https://github.com/kerberos-io/agent/pull/350":
|
||||
raise ValueError("Shared-key exception must reference its reviewed PR record")
|
||||
expires = datetime.fromisoformat(record["expires"].replace("Z", "+00:00"))
|
||||
if expires.tzinfo is None or expires <= now:
|
||||
raise ValueError("Shared-key exception expired or lacks timezone")
|
||||
if (record.get("target") != "machinery/src/config/main.go"
|
||||
or record.get("rule_id") != "private-key"
|
||||
or record.get("category") != "AsymmetricPrivateKey"
|
||||
or record.get("severity") != "HIGH"
|
||||
or type(record.get("start_line")) is not int
|
||||
or record["start_line"] < 1
|
||||
or record.get("end_line") != record["start_line"]):
|
||||
raise ValueError("Shared-key exception has an unexpected finding scope")
|
||||
root = Path(source_root).resolve()
|
||||
path = root / record["target"]
|
||||
if path.resolve() != path or hashlib.sha256(path.read_bytes()).hexdigest() != record.get("file_sha256"):
|
||||
raise ValueError("Shared-key source file changed or is a symlink; renewed review required")
|
||||
expected = (record["target"], record["rule_id"], record["category"],
|
||||
record["severity"], record["start_line"], record["end_line"])
|
||||
matches = [
|
||||
finding for result in report["Results"]
|
||||
for finding in result.get("Secrets", [])
|
||||
if secret_identity(result.get("Target"), finding) == expected
|
||||
]
|
||||
if len(matches) != 1:
|
||||
raise ValueError("Shared-key exception must match exactly one existing source finding")
|
||||
return [dict(record)]
|
||||
|
||||
|
||||
def check_report(report, image=False, source=False, approved_exceptions=()):
|
||||
if report.get("SchemaVersion") != 2 or not isinstance(report.get("Results"), list):
|
||||
raise ValueError("Missing or unsupported Trivy report")
|
||||
failures = []
|
||||
approved_secrets = {
|
||||
(record["target"], record["rule_id"], record["category"], record["severity"],
|
||||
record["start_line"], record["end_line"])
|
||||
for record in approved_exceptions
|
||||
} if source and not image else set()
|
||||
for result in report["Results"]:
|
||||
if result.get("Errors"):
|
||||
failures.append(f"Scan errors in {result.get('Target')}: {result['Errors']}")
|
||||
if result.get("MisconfSummary", {}).get("Exceptions", 0):
|
||||
failures.append(f"Unapproved misconfiguration exceptions in {result.get('Target')}")
|
||||
for kind in ("Vulnerabilities", "Secrets", "Misconfigurations"):
|
||||
for finding in result.get(kind, []):
|
||||
if kind == "Misconfigurations" and finding.get("Status") == "PASS":
|
||||
continue
|
||||
if kind == "Misconfigurations" and finding.get("Status") != "FAIL":
|
||||
failures.append(f"Unexpected/suppressed misconfiguration status: {finding.get('Status')}")
|
||||
severity = finding.get("Severity", "UNKNOWN")
|
||||
if kind == "Secrets" and secret_identity(result.get("Target"), finding) in approved_secrets:
|
||||
continue
|
||||
if severity not in ("LOW", "MEDIUM"):
|
||||
failures.append(f"{result.get('Target')}: {kind}: "
|
||||
f"{finding.get('VulnerabilityID', finding.get('ID', finding.get('RuleID')))} "
|
||||
f"{severity}")
|
||||
if image:
|
||||
# A scratch image without package metadata must not yield a false clean OS scan.
|
||||
if not report.get("Metadata", {}).get("OS", {}).get("Family"):
|
||||
failures.append("No OS detected: preserve runtime OS/package metadata")
|
||||
if not any(r.get("Class") == "os-pkgs" and r.get("Packages")
|
||||
for r in report["Results"]):
|
||||
failures.append("No OS package inventory detected")
|
||||
if not any(r.get("Type") == "gobinary" and r.get("Packages")
|
||||
for r in report["Results"]):
|
||||
failures.append("No Go application package inventory detected")
|
||||
if source and not any(
|
||||
r.get("Type") == "yarn" and r.get("Target", "").replace("\\", "/").endswith("ui/yarn.lock")
|
||||
and r.get("Packages") for r in report["Results"]
|
||||
):
|
||||
failures.append("Missing production UI yarn.lock package inventory")
|
||||
return failures
|
||||
|
||||
|
||||
def redact_report(value):
|
||||
"""Keep findings actionable without persisting matches, excerpts or image env/history."""
|
||||
if isinstance(value, list):
|
||||
return [redact_report(item) for item in value]
|
||||
if not isinstance(value, dict):
|
||||
return value
|
||||
result = {}
|
||||
for key, child in value.items():
|
||||
if key.lower() in {"imageconfig", "buildinfo"}:
|
||||
continue
|
||||
if key.lower() in {
|
||||
"match", "code", "lines", "source", "sourcecode", "snippet", "context",
|
||||
"content",
|
||||
}:
|
||||
result[key] = "[REDACTED]"
|
||||
elif key == "Errors":
|
||||
result[key] = ["[REDACTED scanner error]"] if child else []
|
||||
elif key in ("Secrets", "Misconfigurations"):
|
||||
allowed = {
|
||||
"ID", "AVDID", "RuleID", "Type", "Category", "Title", "Severity",
|
||||
"Status", "StartLine", "EndLine", "References",
|
||||
}
|
||||
result[key] = [
|
||||
{field: finding[field] for field in allowed if field in finding}
|
||||
| {"SourceExcerpt": "[REDACTED]"}
|
||||
for finding in child
|
||||
]
|
||||
else:
|
||||
result[key] = redact_report(child)
|
||||
return result
|
||||
|
||||
|
||||
def scan(target, output, platform=None):
|
||||
output.mkdir(parents=True, exist_ok=True)
|
||||
config = output / "scanner.yaml"
|
||||
ignore = output / "empty.ignore"
|
||||
secret_config = output / "secret.yaml"
|
||||
config.write_text("{}\n")
|
||||
secret_config.write_text("{}\n")
|
||||
ignore.write_text("")
|
||||
# Do not consume repository trivy.yaml/.trivyignore or TRIVY_* overrides.
|
||||
env = {k: v for k, v in os.environ.items() if not k.startswith("TRIVY_")}
|
||||
command = [
|
||||
"trivy", "image" if platform else "fs", "--config", str(config),
|
||||
"--cache-dir", ".ci-tools/trivy-cache",
|
||||
"--ignorefile", str(ignore), "--secret-config", str(secret_config),
|
||||
"--format", "json", "--exit-code", "0",
|
||||
"--scanners", "vuln,secret,misconfig",
|
||||
"--severity", "UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL", "--timeout", "20m",
|
||||
"--list-all-pkgs", "--detection-priority", "comprehensive",
|
||||
]
|
||||
if platform:
|
||||
command += ["--platform", platform, "--pkg-types", "os,library",
|
||||
"--image-config-scanners", "secret,misconfig"]
|
||||
else:
|
||||
# Include development/build dependencies too: none are silently exempted.
|
||||
# Trivy marks Dev packages using the adjacent package.json and yarn.lock.
|
||||
command += ["--pkg-types", "library", "--include-dev-deps"]
|
||||
command.append(target)
|
||||
# Never write raw scanner output, even on scanner failure/interruption. stderr
|
||||
# may contain source excerpts too; retain only a safe exit-status diagnostic.
|
||||
completed = subprocess.run(command, env=env, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE, text=True, check=False)
|
||||
(output / "scanner.log").write_text(
|
||||
f"Trivy exit status: {completed.returncode}\n"
|
||||
"Raw scanner stdout/stderr omitted; scan.json is redacted before persistence.\n")
|
||||
if completed.returncode:
|
||||
raise ValueError(f"Trivy failed with exit status {completed.returncode}; raw diagnostics withheld")
|
||||
try:
|
||||
report = redact_report(json.loads(completed.stdout))
|
||||
except ValueError:
|
||||
raise ValueError("Invalid scanner JSON; raw output withheld") from None
|
||||
(output / "scan.json").write_text(json.dumps(report, indent=2) + "\n")
|
||||
approved = []
|
||||
exception_failures = []
|
||||
if not platform:
|
||||
try:
|
||||
policy = json.loads(Path(__file__).with_name("image-scan-exceptions.json").read_text())
|
||||
(output / "exception-policy.json").write_text(json.dumps(policy, indent=2) + "\n")
|
||||
approved = approve_shared_key(report, target, policy)
|
||||
except (OSError, ValueError, TypeError, KeyError) as error:
|
||||
exception_failures.append(f"Shared-key exception invalid: {error}")
|
||||
(output / "exception-decisions.json").write_text(json.dumps({
|
||||
"approved_exceptions": approved, "failures": exception_failures,
|
||||
}, indent=2) + "\n")
|
||||
failures = exception_failures + check_report(
|
||||
report, image=bool(platform), source=not platform, approved_exceptions=approved)
|
||||
if not platform:
|
||||
inventory = [{
|
||||
"target": result.get("Target"), "type": result.get("Type"),
|
||||
"packages": [{"name": pkg.get("Name"), "version": pkg.get("Version"),
|
||||
"scope": "development" if pkg.get("Dev") else "production-or-unclassified"}
|
||||
for pkg in result.get("Packages", [])],
|
||||
} for result in report["Results"] if result.get("Packages")]
|
||||
(output / "application-inventory.json").write_text(json.dumps({
|
||||
"policy": "All production and development/build dependencies are gated; "
|
||||
"only the reviewed, exact shared-key secret exception may apply.",
|
||||
"inventories": inventory,
|
||||
}, indent=2) + "\n")
|
||||
converted = subprocess.run([
|
||||
"trivy", "convert", "--cache-dir", ".ci-tools/trivy-cache",
|
||||
"--format", "spdx-json", "--output", str(output / "sbom.spdx.json"),
|
||||
str(output / "scan.json"),
|
||||
], env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
|
||||
if converted.returncode:
|
||||
raise ValueError(f"SPDX conversion failed with exit status {converted.returncode}")
|
||||
sbom = json.loads((output / "sbom.spdx.json").read_text())
|
||||
if not sbom.get("spdxVersion") or not sbom.get("packages"):
|
||||
failures.append("Missing/empty SPDX SBOM")
|
||||
return failures
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("target", help="Repository root, or final image reference with --platform")
|
||||
parser.add_argument("output", type=Path, help="Directory for redacted reports and SPDX SBOM")
|
||||
parser.add_argument("--platform", help="Image platform, e.g. linux/amd64; omit for source/UI scanning")
|
||||
args = parser.parse_args()
|
||||
args.output.mkdir(parents=True, exist_ok=True)
|
||||
approved = []
|
||||
try:
|
||||
failures = scan(args.target, args.output, args.platform)
|
||||
approved = json.loads((args.output / "exception-decisions.json").read_text())["approved_exceptions"]
|
||||
except (OSError, ValueError, subprocess.CalledProcessError) as error:
|
||||
failures = [f"Scanner/evidence error: {error}"]
|
||||
(args.output / "policy.json").write_text(json.dumps({
|
||||
"target": args.target, "platform": args.platform, "failures": failures,
|
||||
"approved_exceptions": approved, "passed": not failures,
|
||||
}, indent=2) + "\n")
|
||||
for failure in failures:
|
||||
print(failure, file=sys.stderr)
|
||||
return int(bool(failures))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"required_exceptions": [
|
||||
{
|
||||
"id": "remote-terminal-pty",
|
||||
"status": "pending",
|
||||
"reason": "The product retains functional remote terminal/PTY support, contrary to the no-shell baseline.",
|
||||
"owner": null,
|
||||
"expires": null,
|
||||
"approved_by": null,
|
||||
"approval_url": null
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Release-only policy gate. Approval records require a reviewed repository change."""
|
||||
|
||||
from datetime import datetime, timezone
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
|
||||
def check_policy(policy, now=None):
|
||||
now = now or datetime.now(timezone.utc)
|
||||
records = policy.get("required_exceptions")
|
||||
if not isinstance(records, list) or not records:
|
||||
return ["Required exception records are missing"]
|
||||
if {record.get("id") for record in records} != {"remote-terminal-pty"}:
|
||||
return ["Required remote-terminal-pty exception record is missing or unexpected"]
|
||||
failures = []
|
||||
for record in records:
|
||||
name = record["id"]
|
||||
if record.get("status") != "approved":
|
||||
failures.append(f"{name}: required exception is PENDING, not approved")
|
||||
continue
|
||||
if not all(isinstance(record.get(key), str) and record[key].strip()
|
||||
for key in ("owner", "approved_by", "reason", "approval_url", "expires")):
|
||||
failures.append(f"{name}: missing owner/approver/reason/approval evidence/expiry")
|
||||
continue
|
||||
if not record["approval_url"].startswith("https://github.com/kerberos-io/agent/"):
|
||||
failures.append(f"{name}: approval must reference this repository's reviewed record")
|
||||
try:
|
||||
expires = datetime.fromisoformat(record["expires"].replace("Z", "+00:00"))
|
||||
if expires.tzinfo is None or expires <= now:
|
||||
failures.append(f"{name}: approval expired or lacks timezone")
|
||||
except ValueError:
|
||||
failures.append(f"{name}: invalid approval expiry")
|
||||
return failures
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
failures = check_policy(json.loads(Path(sys.argv[1]).read_text()))
|
||||
except (OSError, ValueError, TypeError, KeyError) as error:
|
||||
failures = [f"Invalid release policy: {error}"]
|
||||
for failure in failures:
|
||||
print(failure, file=sys.stderr)
|
||||
sys.exit(bool(failures))
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"exceptions": [
|
||||
{
|
||||
"id": "shared-recording-signing-key",
|
||||
"status": "approved",
|
||||
"owner": "@cedricve",
|
||||
"approved_by": "@cedricve",
|
||||
"approval_url": "https://github.com/kerberos-io/agent/pull/350",
|
||||
"expires": "2026-12-05T23:59:59Z",
|
||||
"reason": "User approved temporary retention of the existing shared recording-signing key to preserve recording verification trust and startup behavior. Anyone possessing this shared private key can forge signatures under that identity.",
|
||||
"target": "machinery/src/config/main.go",
|
||||
"file_sha256": "e28a0bf6ae892559709e8ec534cfc7b7cb55180e33415461d966c1afe53ca25b",
|
||||
"rule_id": "private-key",
|
||||
"category": "AsymmetricPrivateKey",
|
||||
"severity": "HIGH",
|
||||
"start_line": 710,
|
||||
"end_line": 710
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
# Public OCI index pins the platform-specific executable without GitHub API access.
|
||||
version=0.76.1
|
||||
image=ghcr.io/aquasecurity/trivy:0.76.1@sha256:790fd66d1697395d8693d1acaa1ea702406a20f109b6fc7bac8db623eca6c06c
|
||||
evidence_dir="${1:-evidence/scanner-install}"
|
||||
mkdir -p "$evidence_dir" .ci-tools
|
||||
stage=host-platform
|
||||
platform=
|
||||
cid=
|
||||
finish() {
|
||||
result=$?
|
||||
trap - EXIT
|
||||
if [[ -n "$cid" ]]; then
|
||||
docker rm -f "$cid" >/dev/null 2>&1 || true
|
||||
fi
|
||||
rm -f .ci-tools/trivy.new
|
||||
python3 - "$evidence_dir/install.json" "$result" "$stage" "$image" "$platform" "$version" <<'PY'
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
path, code, stage, image, platform, version = sys.argv[1:]
|
||||
record = {
|
||||
"status": "installed" if code == "0" else "failed",
|
||||
"exit_code": int(code), "stage": stage, "image": image, "platform": platform,
|
||||
"binary_source": "/usr/local/bin/trivy", "expected_version": version,
|
||||
}
|
||||
if code == "0":
|
||||
record["binary_sha256"] = hashlib.sha256(Path(".ci-tools/trivy").read_bytes()).hexdigest()
|
||||
Path(path).write_text(json.dumps(record, indent=2) + "\n")
|
||||
PY
|
||||
exit "$result"
|
||||
}
|
||||
trap finish EXIT
|
||||
case "$(uname -m)" in
|
||||
x86_64) platform=linux/amd64 ;;
|
||||
aarch64|arm64) platform=linux/arm64 ;;
|
||||
*) echo "Unsupported scanner host architecture" >&2; exit 1 ;;
|
||||
esac
|
||||
stage=pull
|
||||
docker pull --platform "$platform" "$image"
|
||||
stage=create
|
||||
cid=$(docker create --platform "$platform" "$image")
|
||||
stage=extract
|
||||
docker cp "$cid:/usr/local/bin/trivy" .ci-tools/trivy.new
|
||||
chmod 0755 .ci-tools/trivy.new
|
||||
stage=verify-version
|
||||
.ci-tools/trivy.new --version | grep -Fx "Version: $version"
|
||||
mv .ci-tools/trivy.new .ci-tools/trivy
|
||||
stage=publish-path
|
||||
if [[ -n "${GITHUB_PATH:-}" ]]; then
|
||||
echo "$PWD/.ci-tools" >> "$GITHUB_PATH"
|
||||
fi
|
||||
stage=complete
|
||||
@@ -0,0 +1,288 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Focused release guard tests; no registry, signing, or scanner network access."""
|
||||
|
||||
from datetime import datetime, timezone
|
||||
import copy
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
ROOT = Path(__file__).parent
|
||||
|
||||
|
||||
def load(name):
|
||||
spec = importlib.util.spec_from_file_location(name, ROOT / f"{name}.py")
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
scanner = load("image-policy")
|
||||
release = load("image-release-policy")
|
||||
evidence = load("image-evidence")
|
||||
|
||||
|
||||
class ScanPolicyTests(unittest.TestCase):
|
||||
def report(self, severity=None, kind="Vulnerabilities"):
|
||||
result = {"Class": "os-pkgs", "Packages": [{"Name": "libc6"}]}
|
||||
if severity:
|
||||
result[kind] = [{"Severity": severity, "Status": "FAIL", "ID": "fixture"}]
|
||||
return {"SchemaVersion": 2, "Metadata": {"OS": {"Family": "debian"}},
|
||||
"Results": [result, {"Class": "lang-pkgs", "Type": "gobinary",
|
||||
"Packages": [{"Name": "stdlib"}]}]}
|
||||
|
||||
def test_low_and_medium_are_not_blocking(self):
|
||||
for severity in ("LOW", "MEDIUM"):
|
||||
self.assertEqual(scanner.check_report(self.report(severity), image=True), [])
|
||||
|
||||
def test_high_critical_unknown_and_unrecognized_block(self):
|
||||
for kind in ("Vulnerabilities", "Secrets", "Misconfigurations"):
|
||||
for severity in ("HIGH", "CRITICAL", "UNKNOWN", "invalid"):
|
||||
with self.subTest(kind=kind, severity=severity):
|
||||
self.assertTrue(scanner.check_report(self.report(severity, kind), image=True))
|
||||
|
||||
def test_missing_inventory_blocks_false_clean_scratch_scan(self):
|
||||
report = self.report()
|
||||
report["Metadata"] = {}
|
||||
report["Results"] = []
|
||||
self.assertEqual(len(scanner.check_report(report, image=True)), 3)
|
||||
|
||||
def test_empty_os_inventory_blocks(self):
|
||||
report = self.report()
|
||||
report["Results"][0]["Packages"] = []
|
||||
self.assertTrue(scanner.check_report(report, image=True))
|
||||
|
||||
def test_report_errors_and_suppression_summary_block(self):
|
||||
report = self.report()
|
||||
report["Results"][0]["Errors"] = ["fixture scanner error"]
|
||||
report["Results"][0]["MisconfSummary"] = {"Exceptions": 1}
|
||||
self.assertEqual(len(scanner.check_report(report)), 2)
|
||||
|
||||
def test_missing_or_unsupported_report_blocks(self):
|
||||
for report in ({}, {"SchemaVersion": 1, "Results": []}):
|
||||
with self.assertRaises(ValueError):
|
||||
scanner.check_report(report)
|
||||
|
||||
def test_suppressed_misconfiguration_blocks(self):
|
||||
report = self.report("LOW", "Misconfigurations")
|
||||
report["Results"][0]["Misconfigurations"][0]["Status"] = "EXCEPTION"
|
||||
self.assertTrue(scanner.check_report(report))
|
||||
|
||||
def test_scanner_errors_are_not_ignored(self):
|
||||
directory = unittest.mock.MagicMock()
|
||||
with patch.object(scanner.subprocess, "run",
|
||||
side_effect=subprocess.CalledProcessError(1, ["trivy"])):
|
||||
with self.assertRaises(subprocess.CalledProcessError):
|
||||
scanner.scan("fixture", directory, "linux/amd64")
|
||||
|
||||
def test_source_requires_ui_lockfile_inventory(self):
|
||||
report = self.report()
|
||||
self.assertTrue(scanner.check_report(report, source=True))
|
||||
report["Results"].append({"Type": "yarn", "Target": "ui/yarn.lock",
|
||||
"Packages": [{"Name": "react", "Version": "17.0.2"}]})
|
||||
self.assertEqual(scanner.check_report(report, source=True), [])
|
||||
report["Results"][-1]["Vulnerabilities"] = [{"Severity": "HIGH", "VulnerabilityID": "fixture"}]
|
||||
self.assertTrue(scanner.check_report(report, source=True))
|
||||
|
||||
def test_secret_and_source_excerpts_are_removed_without_waiving_findings(self):
|
||||
marker = "sensitive-fixture-text-not-a-real-credential"
|
||||
report = self.report("HIGH", "Secrets")
|
||||
report["Metadata"]["ImageConfig"] = {"config": {"Env": [marker]}}
|
||||
report["Metadata"]["BuildInfo"] = {"attrs": {"secret": marker}}
|
||||
report["Results"][0]["Secrets"][0].update(
|
||||
Match=marker, Code={"Lines": [{"Content": marker}]}, Message=marker,
|
||||
UnexpectedFutureExcerptField=marker, RuleID="private-key-fixture")
|
||||
report["Results"][0]["Misconfigurations"] = [{
|
||||
"ID": "fixture", "Severity": "HIGH", "Status": "FAIL",
|
||||
"Message": marker, "CauseMetadata": {"Code": {"Lines": [{"Content": marker}]}}
|
||||
}]
|
||||
report["Results"][0]["Errors"] = [marker]
|
||||
redacted = scanner.redact_report(report)
|
||||
self.assertNotIn(marker, json.dumps(redacted))
|
||||
self.assertNotIn("ImageConfig", redacted["Metadata"])
|
||||
self.assertTrue(scanner.check_report(redacted, image=True))
|
||||
self.assertEqual(redacted["Results"][0]["Secrets"][0]["RuleID"], "private-key-fixture")
|
||||
|
||||
def test_source_scan_captures_output_in_memory_and_generates_sbom(self):
|
||||
report = self.report()
|
||||
report["Results"].append({"Type": "yarn", "Target": "ui/yarn.lock",
|
||||
"Packages": [{"Name": "fixture", "Version": "1.0", "Dev": True}]})
|
||||
directory = unittest.mock.MagicMock()
|
||||
directory.__truediv__.return_value.read_text.return_value = json.dumps({
|
||||
"spdxVersion": "SPDX-2.3", "packages": [{"name": "fixture"}]})
|
||||
completed = subprocess.CompletedProcess(["trivy"], 0, stdout=json.dumps(report), stderr="")
|
||||
with patch.object(scanner.subprocess, "run", return_value=completed) as run, \
|
||||
patch.object(scanner, "approve_shared_key", return_value=[]):
|
||||
self.assertEqual(scanner.scan("fixture", directory), [])
|
||||
command = run.call_args_list[0].args[0]
|
||||
self.assertIn("--include-dev-deps", command)
|
||||
self.assertIn("vuln,secret,misconfig", command)
|
||||
self.assertNotIn("--output", command)
|
||||
self.assertEqual(run.call_args_list[0].kwargs["stdout"], subprocess.PIPE)
|
||||
self.assertEqual(run.call_args_list[1].args[0][1], "convert")
|
||||
|
||||
def test_raw_scanner_error_diagnostics_are_not_persisted(self):
|
||||
directory = unittest.mock.MagicMock()
|
||||
marker = "sensitive-fixture-text-not-a-real-credential"
|
||||
completed = subprocess.CompletedProcess(["trivy"], 1, stdout=marker, stderr=marker)
|
||||
with patch.object(scanner.subprocess, "run", return_value=completed):
|
||||
with self.assertRaisesRegex(ValueError, "exit status 1"):
|
||||
scanner.scan("fixture", directory)
|
||||
self.assertNotIn(marker, str(directory.mock_calls))
|
||||
|
||||
|
||||
class SharedKeyExceptionTests(unittest.TestCase):
|
||||
NOW = datetime(2026, 11, 5, tzinfo=timezone.utc)
|
||||
|
||||
def setUp(self):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
self.root = Path(self.directory.name)
|
||||
self.path = self.root / "machinery/src/config/main.go"
|
||||
self.path.parent.mkdir(parents=True)
|
||||
self.path.write_text("non-secret source fixture\n")
|
||||
self.policy = json.loads((ROOT / "image-scan-exceptions.json").read_text())
|
||||
self.record = self.policy["exceptions"][0]
|
||||
self.record["file_sha256"] = hashlib.sha256(self.path.read_bytes()).hexdigest()
|
||||
self.finding = {
|
||||
"RuleID": self.record["rule_id"], "Category": self.record["category"],
|
||||
"Severity": "HIGH", "StartLine": 710, "EndLine": 710,
|
||||
}
|
||||
self.report = {"SchemaVersion": 2, "Results": [
|
||||
{"Target": self.record["target"], "Secrets": [self.finding]},
|
||||
{"Target": "ui/yarn.lock", "Type": "yarn", "Packages": [{"Name": "react"}]},
|
||||
]}
|
||||
|
||||
def approved(self):
|
||||
return scanner.approve_shared_key(self.report, self.root, self.policy, self.NOW)
|
||||
|
||||
def test_exact_key_is_approved_but_finding_is_preserved(self):
|
||||
original = copy.deepcopy(self.report)
|
||||
approved = self.approved()
|
||||
self.assertTrue(scanner.check_report(self.report, source=True))
|
||||
self.assertEqual(scanner.check_report(
|
||||
self.report, source=True, approved_exceptions=approved), [])
|
||||
self.assertEqual(self.report, original)
|
||||
self.assertEqual(approved[0]["id"], "shared-recording-signing-key")
|
||||
|
||||
def test_other_secrets_and_vulnerabilities_still_block(self):
|
||||
approved = self.approved()
|
||||
result = self.report["Results"][0]
|
||||
result["Secrets"].append(dict(self.finding, StartLine=711, EndLine=711))
|
||||
result["Vulnerabilities"] = [{"VulnerabilityID": "fixture", "Severity": "CRITICAL"}]
|
||||
self.assertEqual(len(scanner.check_report(
|
||||
self.report, source=True, approved_exceptions=approved)), 2)
|
||||
|
||||
def test_exception_never_applies_to_image_or_non_source_scans(self):
|
||||
approved = self.approved()
|
||||
self.assertTrue(scanner.check_report(self.report, approved_exceptions=approved))
|
||||
self.assertTrue(scanner.check_report(
|
||||
self.report, image=True, source=True, approved_exceptions=approved))
|
||||
|
||||
def test_expiry_is_enforced_at_boundary(self):
|
||||
expiry = datetime(2026, 12, 5, 23, 59, 59, tzinfo=timezone.utc)
|
||||
with self.assertRaisesRegex(ValueError, "expired"):
|
||||
scanner.approve_shared_key(self.report, self.root, self.policy, expiry)
|
||||
self.record["expires"] = "2026-12-05"
|
||||
with self.assertRaisesRegex(ValueError, "timezone"):
|
||||
self.approved()
|
||||
|
||||
def test_incomplete_or_unapproved_metadata_blocks(self):
|
||||
for field in ("owner", "approved_by", "reason", "approval_url", "expires", "status"):
|
||||
with self.subTest(field=field):
|
||||
original = self.record[field]
|
||||
self.record[field] = ""
|
||||
with self.assertRaises(ValueError):
|
||||
self.approved()
|
||||
self.record[field] = original
|
||||
self.record["approval_url"] = "https://example.com/unreviewed"
|
||||
with self.assertRaises(ValueError):
|
||||
self.approved()
|
||||
|
||||
def test_changed_source_or_symlink_requires_review(self):
|
||||
self.path.write_text("changed source fixture\n")
|
||||
with self.assertRaisesRegex(ValueError, "changed"):
|
||||
self.approved()
|
||||
target = self.root / "other.go"
|
||||
self.path.rename(target)
|
||||
self.path.symlink_to(target)
|
||||
with self.assertRaisesRegex(ValueError, "symlink"):
|
||||
self.approved()
|
||||
|
||||
def test_changed_finding_does_not_match(self):
|
||||
for field, value in (("RuleID", "other"), ("Category", "other"),
|
||||
("Severity", "CRITICAL"), ("StartLine", 711), ("EndLine", 711)):
|
||||
with self.subTest(field=field):
|
||||
original = self.finding[field]
|
||||
self.finding[field] = value
|
||||
with self.assertRaisesRegex(ValueError, "exactly one"):
|
||||
self.approved()
|
||||
self.finding[field] = original
|
||||
|
||||
def test_duplicate_missing_or_broadened_records_block(self):
|
||||
self.policy["exceptions"].append(dict(self.record))
|
||||
with self.assertRaises(ValueError):
|
||||
self.approved()
|
||||
self.policy["exceptions"].pop()
|
||||
self.report["Results"][0]["Secrets"].append(dict(self.finding))
|
||||
with self.assertRaisesRegex(ValueError, "exactly one"):
|
||||
self.approved()
|
||||
self.report["Results"][0]["Secrets"] = []
|
||||
with self.assertRaisesRegex(ValueError, "exactly one"):
|
||||
self.approved()
|
||||
self.record["target"] = "../other.go"
|
||||
with self.assertRaisesRegex(ValueError, "scope"):
|
||||
self.approved()
|
||||
|
||||
def test_checked_in_record_matches_unchanged_source(self):
|
||||
report = copy.deepcopy(self.report)
|
||||
policy = json.loads((ROOT / "image-scan-exceptions.json").read_text())
|
||||
self.assertEqual(len(scanner.approve_shared_key(
|
||||
report, ROOT.parent.parent, policy, self.NOW)), 1)
|
||||
|
||||
|
||||
class ReleasePolicyTests(unittest.TestCase):
|
||||
NOW = datetime(2026, 11, 4, tzinfo=timezone.utc)
|
||||
|
||||
def test_checked_in_state_blocks_publication(self):
|
||||
state = json.loads((ROOT / "image-release-policy.json").read_text())
|
||||
self.assertTrue(release.check_policy(state, self.NOW))
|
||||
|
||||
def test_missing_records_block(self):
|
||||
for state in ({}, {"required_exceptions": []},
|
||||
{"required_exceptions": [{"id": "unrelated"}]}):
|
||||
self.assertTrue(release.check_policy(state, self.NOW))
|
||||
|
||||
def test_expired_or_incomplete_approval_blocks(self):
|
||||
state = json.loads((ROOT / "image-release-policy.json").read_text())
|
||||
record = state["required_exceptions"][0]
|
||||
record["status"] = "approved"
|
||||
self.assertTrue(release.check_policy(state, self.NOW))
|
||||
record.update(owner="test-fixture", approved_by="test-fixture",
|
||||
approval_url="https://github.com/kerberos-io/agent/issues/1",
|
||||
expires="2020-01-01T00:00:00Z")
|
||||
self.assertTrue(release.check_policy(state, self.NOW))
|
||||
record["expires"] = "invalid"
|
||||
self.assertTrue(release.check_policy(state, self.NOW))
|
||||
record["expires"] = "2027-01-01"
|
||||
self.assertTrue(release.check_policy(state, self.NOW))
|
||||
|
||||
|
||||
class ProvenanceTests(unittest.TestCase):
|
||||
def test_base_digest_retained(self):
|
||||
material = {"uri": "pkg:docker/debian@trixie", "digest": {"sha256": "a" * 64}}
|
||||
self.assertEqual(list(evidence.materials({"SLSA": {"materials": [material]}})), [material])
|
||||
|
||||
def test_missing_digest_rejected(self):
|
||||
with self.assertRaises(ValueError):
|
||||
list(evidence.materials({"uri": "pkg:docker/debian@trixie"}))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -17,7 +17,7 @@ jobs:
|
||||
- name: Set up Go
|
||||
uses: actions/setup-go@v5
|
||||
with:
|
||||
go-version: "1.25.x"
|
||||
go-version: "1.26.10"
|
||||
check-latest: true
|
||||
cache: true
|
||||
cache-dependency-path: machinery/go.sum
|
||||
@@ -32,9 +32,9 @@ jobs:
|
||||
libswscale-dev \
|
||||
pkg-config
|
||||
- name: Get dependencies
|
||||
run: cd machinery && go mod download
|
||||
run: cd machinery && go mod download && go mod verify
|
||||
- name: Build
|
||||
run: cd machinery && go build -v ./...
|
||||
run: cd machinery && go build -mod=readonly -trimpath -buildvcs=false -v ./...
|
||||
- name: Vet
|
||||
run: cd machinery && go vet -v ./...
|
||||
- name: Test
|
||||
|
||||
@@ -0,0 +1,324 @@
|
||||
name: Verified image publication
|
||||
on:
|
||||
workflow_call:
|
||||
inputs:
|
||||
tag:
|
||||
type: string
|
||||
default: ""
|
||||
source_ref:
|
||||
type: string
|
||||
required: true
|
||||
nightly:
|
||||
type: boolean
|
||||
default: false
|
||||
publish_latest:
|
||||
type: boolean
|
||||
default: false
|
||||
secrets:
|
||||
DOCKER_USERNAME:
|
||||
required: true
|
||||
DOCKER_PASSWORD:
|
||||
required: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
# No parallel run can overwrite a customer tag while another run verifies it.
|
||||
concurrency:
|
||||
group: image-publication-${{ inputs.nightly && 'nightly' || 'release' }}
|
||||
cancel-in-progress: false
|
||||
|
||||
defaults:
|
||||
run:
|
||||
shell: bash
|
||||
|
||||
jobs:
|
||||
resolve:
|
||||
runs-on: ubuntu-24.04
|
||||
permissions:
|
||||
contents: write
|
||||
outputs:
|
||||
sha: ${{ steps.source.outputs.sha }}
|
||||
tag: ${{ steps.source.outputs.tag }}
|
||||
created: ${{ steps.source.outputs.created }}
|
||||
matrix: ${{ steps.source.outputs.matrix }}
|
||||
repository: ${{ steps.source.outputs.repository }}
|
||||
staging_repository: ${{ steps.source.outputs.staging_repository }}
|
||||
steps:
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Validate requested tag
|
||||
env:
|
||||
TAG: ${{ inputs.tag }}
|
||||
NIGHTLY: ${{ inputs.nightly }}
|
||||
run: |
|
||||
if [[ "$NIGHTLY" != true && ! "$TAG" =~ ^[a-zA-Z0-9_][a-zA-Z0-9_.-]{0,127}$ ]]; then
|
||||
echo "Invalid Docker tag" >&2
|
||||
exit 1
|
||||
fi
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
|
||||
with:
|
||||
ref: ${{ inputs.source_ref }}
|
||||
path: source
|
||||
persist-credentials: false
|
||||
- name: Resolve once for every architecture
|
||||
id: source
|
||||
env:
|
||||
TAG: ${{ inputs.tag }}
|
||||
NIGHTLY: ${{ inputs.nightly }}
|
||||
run: |
|
||||
sha=$(git -C source rev-parse HEAD)
|
||||
[[ "$sha" =~ ^[a-f0-9]{40}$ ]]
|
||||
created=$(date -u +%Y-%m-%dT%H:%M:%SZ)
|
||||
repository=kerberos/agent
|
||||
staging_repository=kerberos/agent-arch
|
||||
matrix='{"include":[{"architecture":"amd64","runner":"ubuntu-24.04"},{"architecture":"arm64","runner":"ubuntu-24.04-arm"}]}'
|
||||
if [[ "$NIGHTLY" == true ]]; then
|
||||
TAG="${sha:0:7}"
|
||||
repository=kerberos/agent-nightly
|
||||
staging_repository="$repository"
|
||||
# Keep arm/v6: the pinned Go trixie base currently lacks this platform.
|
||||
# Its build must fail rather than publishing an incomplete nightly index.
|
||||
matrix='{"include":[{"architecture":"amd64","runner":"ubuntu-24.04"},{"architecture":"arm64","runner":"ubuntu-24.04-arm"},{"architecture":"arm/v7","runner":"ubuntu-24.04"},{"architecture":"arm/v6","runner":"ubuntu-24.04"}]}'
|
||||
fi
|
||||
{
|
||||
echo "sha=$sha"
|
||||
echo "tag=$TAG"
|
||||
echo "created=$created"
|
||||
echo "repository=$repository"
|
||||
echo "staging_repository=$staging_repository"
|
||||
echo "matrix=$matrix"
|
||||
} >> "$GITHUB_OUTPUT"
|
||||
mkdir -p evidence
|
||||
printf '%s\n' "$sha" > evidence/source-revision.txt
|
||||
printf '%s\n' "$created" > evidence/created.txt
|
||||
printf '%s\n' "$TAG" > evidence/version.txt
|
||||
cp .github/scripts/image-release-policy.json evidence/runtime-policy.json
|
||||
- name: Validate fail-closed policy helpers
|
||||
run: python3 .github/scripts/test-image-policy.py
|
||||
- name: Keep existing GitHub release unpublished until gates pass
|
||||
if: ${{ !inputs.nightly }}
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
TAG: ${{ steps.source.outputs.tag }}
|
||||
run: |
|
||||
# A release:created event may refer to an already public release.
|
||||
# Return it to draft immediately; do not imply this run has verified it.
|
||||
gh api --paginate "repos/$GITHUB_REPOSITORY/releases" --jq '.[]' | jq -s . > evidence/releases.json
|
||||
release_id=$(jq -r --arg tag "$TAG" '.[] | select(.tag_name == $tag) | .id' evidence/releases.json)
|
||||
if [[ -n "$release_id" ]]; then
|
||||
gh api --method PATCH "repos/$GITHUB_REPOSITORY/releases/$release_id" -F draft=true > evidence/draft-release.json
|
||||
fi
|
||||
- name: Install pinned public OCI scanner
|
||||
run: bash .github/scripts/install-trivy.sh
|
||||
- name: Source/UI dependency vulnerability, secret and misconfiguration gate with SPDX SBOM
|
||||
run: python3 .github/scripts/image-policy.py source evidence/source
|
||||
- name: Retain source policy evidence
|
||||
if: always()
|
||||
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
|
||||
with:
|
||||
name: image-source-evidence
|
||||
path: evidence/
|
||||
retention-days: 90
|
||||
if-no-files-found: error
|
||||
|
||||
build:
|
||||
needs: resolve
|
||||
runs-on: ${{ matrix.runner }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix: ${{ fromJSON(needs.resolve.outputs.matrix) }}
|
||||
env:
|
||||
ARCH: ${{ matrix.architecture }}
|
||||
VERSION: ${{ needs.resolve.outputs.tag }}
|
||||
REVISION: ${{ needs.resolve.outputs.sha }}
|
||||
CREATED: ${{ needs.resolve.outputs.created }}
|
||||
STAGING_REPOSITORY: ${{ needs.resolve.outputs.staging_repository }}
|
||||
steps:
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
|
||||
with:
|
||||
persist-credentials: false
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
|
||||
with:
|
||||
ref: ${{ needs.resolve.outputs.sha }}
|
||||
path: source
|
||||
persist-credentials: false
|
||||
- uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
|
||||
if: ${{ startsWith(matrix.architecture, 'arm/') }}
|
||||
- uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
|
||||
- uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Build immutable staging image with maximal provenance
|
||||
id: build
|
||||
run: |
|
||||
mkdir -p evidence
|
||||
arch="${ARCH//\//-}"
|
||||
echo "arch=$arch" >> "$GITHUB_OUTPUT"
|
||||
staging="$STAGING_REPOSITORY:ci-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT-$arch"
|
||||
printf '%s\n' "$REVISION" > evidence/source-revision.txt
|
||||
docker buildx build --platform "linux/$ARCH" --provenance=mode=max \
|
||||
--build-arg "VERSION=$VERSION" --build-arg "REVISION=$REVISION" --build-arg "CREATED=$CREATED" \
|
||||
--label "org.opencontainers.image.version=$VERSION" \
|
||||
--label "org.opencontainers.image.revision=$REVISION" \
|
||||
--label "org.opencontainers.image.created=$CREATED" \
|
||||
--label "org.opencontainers.image.source=https://github.com/$GITHUB_REPOSITORY" \
|
||||
--metadata-file evidence/build-metadata.json --tag "$staging" --push source
|
||||
digest=$(jq -er '."containerimage.digest"' evidence/build-metadata.json)
|
||||
[[ "$digest" =~ ^sha256:[a-f0-9]{64}$ ]]
|
||||
image="$STAGING_REPOSITORY@$digest"
|
||||
printf '%s\n' "$image" > evidence/image.txt
|
||||
docker buildx imagetools inspect "$image" --format '{{json .Provenance}}' > evidence/provenance.json
|
||||
python3 .github/scripts/image-evidence.py evidence
|
||||
- name: Extract release payload and smoke test the exact staged image
|
||||
run: |
|
||||
image=$(cat evidence/image.txt)
|
||||
docker pull --platform "linux/$ARCH" "$image"
|
||||
cid=$(docker create --platform "linux/$ARCH" "$image")
|
||||
trap 'docker rm -f "$cid" >/dev/null' EXIT
|
||||
docker cp "$cid:/home/agent" output
|
||||
# Run the existing smoke interface, including emulated nightly architectures.
|
||||
DOCKER_DEFAULT_PLATFORM="linux/$ARCH" sh source/deployments/docker/test-image.sh "$image"
|
||||
arch="${ARCH//\//-}"
|
||||
tar -cf "agent-$arch.tar" -C output .
|
||||
rm -rf output
|
||||
- name: Retain build evidence even on failure
|
||||
if: always()
|
||||
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
|
||||
with:
|
||||
name: image-build-${{ steps.build.outputs.arch || strategy.job-index }}
|
||||
path: evidence/
|
||||
retention-days: 90
|
||||
if-no-files-found: error
|
||||
- name: Retain existing binary artifacts
|
||||
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
|
||||
with:
|
||||
name: agent-${{ steps.build.outputs.arch }}.tar
|
||||
path: agent-*.tar
|
||||
if-no-files-found: error
|
||||
|
||||
verify-publish:
|
||||
needs: [resolve, build]
|
||||
runs-on: ubuntu-24.04
|
||||
permissions:
|
||||
contents: write
|
||||
id-token: write
|
||||
env:
|
||||
REPOSITORY: ${{ needs.resolve.outputs.repository }}
|
||||
STAGING_REPOSITORY: ${{ needs.resolve.outputs.staging_repository }}
|
||||
VERSION: ${{ needs.resolve.outputs.tag }}
|
||||
REVISION: ${{ needs.resolve.outputs.sha }}
|
||||
PUBLISH_LATEST: ${{ inputs.publish_latest }}
|
||||
MATRIX: ${{ needs.resolve.outputs.matrix }}
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
steps:
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
|
||||
with:
|
||||
persist-credentials: false
|
||||
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
|
||||
with:
|
||||
path: artifacts
|
||||
- uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
|
||||
- uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Install scanner
|
||||
run: bash .github/scripts/install-trivy.sh
|
||||
- uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
|
||||
with:
|
||||
cosign-release: v3.1.4
|
||||
- name: Assemble candidate index without publishing version/latest
|
||||
run: |
|
||||
mkdir -p evidence
|
||||
images=()
|
||||
while IFS= read -r arch; do
|
||||
directory="artifacts/image-build-${arch//\//-}"
|
||||
[[ "$(cat "$directory/source-revision.txt")" == "$REVISION" ]]
|
||||
image=$(cat "$directory/image.txt")
|
||||
[[ "$image" =~ ^${STAGING_REPOSITORY}@sha256:[a-f0-9]{64}$ ]]
|
||||
images+=("$image")
|
||||
done < <(jq -r '.include[].architecture' <<< "$MATRIX")
|
||||
candidate="$REPOSITORY:ci-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT"
|
||||
docker buildx imagetools create --tag "$candidate" "${images[@]}"
|
||||
digest=$(docker buildx imagetools inspect "$candidate" --format '{{.Manifest.Digest}}')
|
||||
[[ "$digest" =~ ^sha256:[a-f0-9]{64}$ ]]
|
||||
image="$REPOSITORY@$digest"
|
||||
printf '%s\n' "$image" > evidence/final-image.txt
|
||||
printf '%s\n' "$REVISION" > evidence/source-revision.txt
|
||||
docker buildx imagetools inspect "$image" --raw > evidence/index.json
|
||||
docker buildx imagetools inspect "$image" --format '{{json .Provenance}}' > evidence/provenance.json
|
||||
python3 .github/scripts/image-evidence.py evidence
|
||||
# Every requested runnable platform must be present, with no silent omissions.
|
||||
jq -r '.manifests[] | select(.platform.os == "linux") |
|
||||
.platform | .architecture + (if .variant and .architecture == "arm" then "/" + .variant else "" end)' \
|
||||
evidence/index.json | sort > evidence/actual-platforms.txt
|
||||
jq -r '.include[].architecture' <<< "$MATRIX" | sort > evidence/expected-platforms.txt
|
||||
diff -u evidence/expected-platforms.txt evidence/actual-platforms.txt
|
||||
- name: Scan every final-index platform and enforce findings/errors
|
||||
run: |
|
||||
image=$(cat evidence/final-image.txt)
|
||||
failed=0
|
||||
while IFS= read -r arch; do
|
||||
# Generation uses exit-code 0 only for findings; the helper explicitly
|
||||
# blocks HIGH/CRITICAL/UNKNOWN and any scanner/inventory/SBOM error.
|
||||
if ! python3 .github/scripts/image-policy.py "$image" "evidence/${arch//\//-}" --platform "linux/$arch"; then
|
||||
failed=1
|
||||
fi
|
||||
done < <(jq -r '.include[].architecture' <<< "$MATRIX")
|
||||
exit "$failed"
|
||||
- name: Required release policy exception gate
|
||||
run: |
|
||||
# The product deliberately retains remote terminal/PTY support.
|
||||
# No approval exists. Keep this release-only gate separate from scans;
|
||||
# there is no dispatch input/environment variable that can waive it.
|
||||
cp .github/scripts/image-release-policy.json evidence/runtime-policy.json
|
||||
python3 .github/scripts/image-release-policy.py evidence/runtime-policy.json
|
||||
- name: Sign and verify the FINAL multi-platform digest using GitHub OIDC
|
||||
run: |
|
||||
image=$(cat evidence/final-image.txt)
|
||||
# Fulcio's SAN is job_workflow_ref for this local reusable workflow,
|
||||
# not the caller's filename. Bind the exact repository and executing ref.
|
||||
# For example: https://github.com/kerberos-io/agent/.github/workflows/image-release.yml@refs/heads/master
|
||||
identity="https://github.com/$GITHUB_REPOSITORY/.github/workflows/image-release.yml@$GITHUB_REF"
|
||||
printf '%s\n' "$identity" > evidence/signing-identity.txt
|
||||
cosign sign --yes --bundle evidence/signature.sigstore.json "$image"
|
||||
cosign verify --certificate-identity "$identity" \
|
||||
--certificate-oidc-issuer https://token.actions.githubusercontent.com \
|
||||
"$image" > evidence/signature-verification.json
|
||||
- name: Publish only the already verified and signed digest
|
||||
run: |
|
||||
image=$(cat evidence/final-image.txt)
|
||||
while IFS= read -r arch; do
|
||||
arch="${arch//\//-}"
|
||||
staged=$(cat "artifacts/image-build-$arch/image.txt")
|
||||
# Preserve the existing architecture tag names, after all gates.
|
||||
docker buildx imagetools create --tag "$STAGING_REPOSITORY:arch-$arch-$VERSION" "$staged"
|
||||
done < <(jq -r '.include[].architecture' <<< "$MATRIX")
|
||||
docker buildx imagetools create --tag "$REPOSITORY:$VERSION" "$image"
|
||||
[[ "$(docker buildx imagetools inspect "$REPOSITORY:$VERSION" --format '{{.Manifest.Digest}}')" == "${image##*@}" ]]
|
||||
if [[ "$PUBLISH_LATEST" == true ]]; then
|
||||
docker buildx imagetools create --tag "$REPOSITORY:latest" "$image"
|
||||
[[ "$(docker buildx imagetools inspect "$REPOSITORY:latest" --format '{{.Manifest.Digest}}')" == "${image##*@}" ]]
|
||||
fi
|
||||
- name: Retain final reports/SBOM/provenance/signature even on failure
|
||||
if: always()
|
||||
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
|
||||
with:
|
||||
name: image-final-evidence
|
||||
path: evidence/
|
||||
retention-days: 90
|
||||
if-no-files-found: error
|
||||
- name: Attach binaries and all evidence, then publish GitHub release
|
||||
if: ${{ !inputs.nightly }}
|
||||
run: |
|
||||
tar -czf image-security-evidence.tar.gz evidence artifacts/image-*
|
||||
# Create a draft only if absent. API errors must not masquerade as absence.
|
||||
gh api --paginate "repos/$GITHUB_REPOSITORY/releases" --jq '.[]' | jq -s . > releases.json
|
||||
if ! jq -e --arg tag "$VERSION" '.[] | select(.tag_name == $tag)' releases.json >/dev/null; then
|
||||
gh release create "$VERSION" --target "$REVISION" --title "$VERSION" --notes "" --draft
|
||||
fi
|
||||
gh release upload "$VERSION" artifacts/agent-*.tar/agent-*.tar image-security-evidence.tar.gz --clobber
|
||||
gh release edit "$VERSION" --draft=false --latest --title "$VERSION"
|
||||
@@ -1,62 +1,19 @@
|
||||
name: Nightly build
|
||||
|
||||
on:
|
||||
# Triggers the workflow every day at 9PM (CET).
|
||||
schedule:
|
||||
- cron: "0 22 * * *"
|
||||
# Allows manual triggering from the Actions tab.
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: write
|
||||
|
||||
jobs:
|
||||
nightly-build-amd64:
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [amd64]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
ref: master
|
||||
- name: Set up QEMU
|
||||
uses: docker/setup-qemu-action@v3
|
||||
- name: Set up Docker Buildx
|
||||
id: buildx
|
||||
uses: docker/setup-buildx-action@v3
|
||||
- name: Available platforms
|
||||
run: echo ${{ steps.buildx.outputs.platforms }}
|
||||
- name: Run Buildx
|
||||
run: docker buildx build --build-arg VERSION=$(echo $GITHUB_SHA | cut -c1-7) --platform linux/${{matrix.architecture}} -t kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
|
||||
- name: Create new and append to manifest
|
||||
run: docker buildx imagetools create -t kerberos/agent-nightly:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
|
||||
nightly-build-other:
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [arm64, arm/v7, arm/v6]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
ref: master
|
||||
- name: Set up QEMU
|
||||
uses: docker/setup-qemu-action@v3
|
||||
- name: Set up Docker Buildx
|
||||
id: buildx
|
||||
uses: docker/setup-buildx-action@v3
|
||||
- name: Available platforms
|
||||
run: echo ${{ steps.buildx.outputs.platforms }}
|
||||
- name: Run Buildx
|
||||
run: docker buildx build --build-arg VERSION=$(echo $GITHUB_SHA | cut -c1-7) --platform linux/${{matrix.architecture}} -t kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
|
||||
- name: Create new and append to manifest
|
||||
run: docker buildx imagetools create --append -t kerberos/agent-nightly:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
|
||||
nightly:
|
||||
permissions:
|
||||
contents: read
|
||||
id-token: write
|
||||
uses: ./.github/workflows/image-release.yml
|
||||
with:
|
||||
source_ref: master
|
||||
nightly: true
|
||||
secrets: inherit
|
||||
|
||||
+102
-19
@@ -1,36 +1,119 @@
|
||||
name: Build pull request
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, synchronize]
|
||||
types: [opened, synchronize, reopened]
|
||||
|
||||
env:
|
||||
REPO: kerberos/agent
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
defaults:
|
||||
run:
|
||||
shell: bash
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ${{ matrix.runner }}
|
||||
permissions:
|
||||
contents: read
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- architecture: amd64
|
||||
runner: ubuntu-24.04
|
||||
- architecture: arm64
|
||||
runner: ubuntu-24.04-arm
|
||||
env:
|
||||
ARCH: ${{ matrix.architecture }}
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --build-arg VERSION=$(echo "${{ github.event.pull_request.head.sha }}" | cut -c1-7) -t ${{ matrix.architecture }} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
|
||||
with:
|
||||
name: agent-${{matrix.architecture}}.tar
|
||||
path: agent-${{matrix.architecture}}.tar
|
||||
persist-credentials: false
|
||||
- name: Initialize retained runtime/scanner state
|
||||
run: |
|
||||
mkdir -p evidence/scanner-install
|
||||
printf '%s\n' '{"status":"not_started","reason":"waiting_for_native_build_and_smoke"}' \
|
||||
> evidence/scanner-install/install.json
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
|
||||
with:
|
||||
ref: ${{ github.sha }}
|
||||
path: source
|
||||
persist-credentials: false
|
||||
- uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
|
||||
- name: Validate fail-closed policy helpers
|
||||
run: python3 .github/scripts/test-image-policy.py
|
||||
- name: Build once, populating OCI metadata from CI
|
||||
env:
|
||||
BUILDX_METADATA_PROVENANCE: max
|
||||
run: |
|
||||
mkdir -p evidence/build
|
||||
revision=$(git -C source rev-parse HEAD)
|
||||
version="${revision:0:7}"
|
||||
created=$(date -u +%Y-%m-%dT%H:%M:%SZ)
|
||||
printf '%s\n' "$revision" > evidence/build/source-revision.txt
|
||||
# Classic Docker cannot load an attested index. Disable attestations
|
||||
# only for this local export; BUILDX_METADATA_PROVENANCE=max retains
|
||||
# full build provenance/materials separately, verified below.
|
||||
docker buildx build --platform "linux/$ARCH" --provenance=false \
|
||||
--build-arg "VERSION=$version" --build-arg "REVISION=$revision" --build-arg "CREATED=$created" \
|
||||
--label "org.opencontainers.image.version=$version" \
|
||||
--label "org.opencontainers.image.revision=$revision" \
|
||||
--label "org.opencontainers.image.created=$created" \
|
||||
--label "org.opencontainers.image.source=https://github.com/$GITHUB_REPOSITORY" \
|
||||
--metadata-file evidence/build/build-metadata.json --tag "$ARCH" \
|
||||
--output type=docker source
|
||||
jq -e '."buildx.build.provenance" |
|
||||
select(type == "object" and length > 0) |
|
||||
select(.buildConfig | type == "object" and length > 0)' \
|
||||
evidence/build/build-metadata.json > evidence/build/provenance.json
|
||||
python3 .github/scripts/image-evidence.py evidence/build
|
||||
- name: Extract release payload
|
||||
run: |
|
||||
cid=$(docker create "$ARCH")
|
||||
trap 'docker rm -f "$cid" >/dev/null' EXIT
|
||||
docker cp "$cid:/home/agent" "output-$ARCH"
|
||||
- name: Test production image
|
||||
id: smoke
|
||||
run: sh source/deployments/docker/test-image.sh "$ARCH"
|
||||
- name: Strip binary
|
||||
run: tar -cf "agent-$ARCH.tar" -C "output-$ARCH" . && rm -rf "output-$ARCH"
|
||||
- name: Install pinned public OCI scanner after runtime tests
|
||||
run: bash .github/scripts/install-trivy.sh
|
||||
- name: Source/UI dependency and final image gates with SPDX SBOMs
|
||||
run: |
|
||||
failed=0
|
||||
if ! python3 .github/scripts/image-policy.py source evidence/source; then
|
||||
failed=1
|
||||
fi
|
||||
if ! python3 .github/scripts/image-policy.py "$ARCH" "evidence/$ARCH" --platform "linux/$ARCH"; then
|
||||
failed=1
|
||||
fi
|
||||
exit "$failed"
|
||||
- name: Upload artifact only after secret and vulnerability gates pass
|
||||
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
|
||||
with:
|
||||
name: agent-${{ matrix.architecture }}.tar
|
||||
path: agent-${{ matrix.architecture }}.tar
|
||||
if-no-files-found: error
|
||||
- name: Record runtime result independently of scanner availability
|
||||
if: always()
|
||||
env:
|
||||
SMOKE_OUTCOME: ${{ steps.smoke.outcome }}
|
||||
run: |
|
||||
mkdir -p evidence
|
||||
python3 - <<'PY'
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
Path("evidence/runtime-smoke.json").write_text(json.dumps({
|
||||
"architecture": os.environ["ARCH"],
|
||||
"outcome": os.environ["SMOKE_OUTCOME"],
|
||||
"workflow_revision": os.environ["GITHUB_SHA"],
|
||||
}, indent=2) + "\n")
|
||||
PY
|
||||
- name: Retain reports on failure
|
||||
if: always()
|
||||
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
|
||||
with:
|
||||
name: image-pr-evidence-${{ matrix.architecture }}
|
||||
path: evidence/
|
||||
retention-days: 90
|
||||
if-no-files-found: error
|
||||
|
||||
@@ -1,160 +1,36 @@
|
||||
name: Bump release
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
bump:
|
||||
description: "Which part of the version to bump"
|
||||
description: Which part of the version to bump
|
||||
required: true
|
||||
default: patch
|
||||
type: choice
|
||||
options:
|
||||
- major
|
||||
- minor
|
||||
- patch
|
||||
options: [major, minor, patch]
|
||||
|
||||
permissions:
|
||||
contents: write
|
||||
|
||||
env:
|
||||
REPO: kerberos/agent
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
# Determine the next version, create the GitHub release and expose the tag.
|
||||
bump-release:
|
||||
uses: uug-ai/workflows/.github/workflows/release-bump.yml@main
|
||||
permissions:
|
||||
contents: write
|
||||
# Verified revision supports reserving a tag with an unpublished draft.
|
||||
uses: uug-ai/workflows/.github/workflows/release-bump.yml@f31d4260a833e82228ca0e9b9163231a970feeb8
|
||||
with:
|
||||
bump: ${{ github.event.inputs.bump }}
|
||||
bump: ${{ inputs.bump }}
|
||||
draft: true
|
||||
secrets: inherit
|
||||
|
||||
# Publish the platform image to the uug-ai GitHub Container Registry
|
||||
# (ghcr.io/uug-ai/agent-platform).
|
||||
#release:
|
||||
# needs: bump-release
|
||||
# uses: uug-ai/workflows/.github/workflows/release-create.yml@main
|
||||
# with:
|
||||
# organization: uug-ai
|
||||
# project: ${{ github.event.repository.name }}
|
||||
# tag: ${{ needs.bump-release.outputs.tag }}
|
||||
# docker_context: "."
|
||||
# create_gitops_pr: false
|
||||
# runner_matrix: >-
|
||||
# [
|
||||
# {"architecture":"amd64","runner":"ubuntu-24.04"},
|
||||
# {"architecture":"arm64","runner":"ubuntu-24.04-arm"}
|
||||
# ]
|
||||
# secrets: inherit
|
||||
|
||||
# Everything below mirrors the agent's own release-create.yml pipeline and
|
||||
# publishes the multi-arch image to the kerberos/agent Docker Hub repo, driven
|
||||
# by the freshly bumped tag instead of a `release: created` event.
|
||||
build-amd64:
|
||||
release:
|
||||
needs: bump-release
|
||||
runs-on: ubuntu-24.04
|
||||
permissions:
|
||||
contents: write
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [amd64]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{ needs.bump-release.outputs.tag }} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: agent-${{matrix.architecture}}.tar
|
||||
path: agent-${{matrix.architecture}}.tar
|
||||
|
||||
build-arm64:
|
||||
needs: bump-release
|
||||
runs-on: ubuntu-24.04-arm
|
||||
permissions:
|
||||
contents: write
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [arm64]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{ needs.bump-release.outputs.tag }} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: agent-${{matrix.architecture}}.tar
|
||||
path: agent-${{matrix.architecture}}.tar
|
||||
|
||||
create-manifest:
|
||||
runs-on: ubuntu-24.04
|
||||
needs: [bump-release, build-amd64, build-arm64]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Create and push multi-arch manifest
|
||||
run: |
|
||||
docker manifest create $REPO:${{ needs.bump-release.outputs.tag }} \
|
||||
$REPO-arch:arch-amd64-${{ needs.bump-release.outputs.tag }} \
|
||||
$REPO-arch:arch-arm64-${{ needs.bump-release.outputs.tag }}
|
||||
docker manifest push $REPO:${{ needs.bump-release.outputs.tag }}
|
||||
- name: Create and push latest manifest
|
||||
run: |
|
||||
docker manifest create $REPO:latest \
|
||||
$REPO-arch:arch-amd64-${{ needs.bump-release.outputs.tag }} \
|
||||
$REPO-arch:arch-arm64-${{ needs.bump-release.outputs.tag }}
|
||||
docker manifest push $REPO:latest
|
||||
|
||||
create-release:
|
||||
runs-on: ubuntu-24.04
|
||||
needs: [bump-release, build-amd64, build-arm64]
|
||||
permissions:
|
||||
contents: write
|
||||
steps:
|
||||
- name: Download all artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
- name: Create a release
|
||||
uses: ncipollo/release-action@v1
|
||||
with:
|
||||
latest: true
|
||||
allowUpdates: true
|
||||
name: ${{ needs.bump-release.outputs.tag }}
|
||||
tag: ${{ needs.bump-release.outputs.tag }}
|
||||
generateReleaseNotes: false
|
||||
omitBodyDuringUpdate: true
|
||||
artifacts: "agent-*.tar/agent-*.tar"
|
||||
|
||||
|
||||
id-token: write
|
||||
uses: ./.github/workflows/image-release.yml
|
||||
with:
|
||||
tag: ${{ needs.bump-release.outputs.tag }}
|
||||
source_ref: ${{ format('refs/tags/{0}', needs.bump-release.outputs.tag) }}
|
||||
publish_latest: true
|
||||
secrets: inherit
|
||||
|
||||
@@ -5,118 +5,21 @@ on:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
tag:
|
||||
description: "Tag for the Docker image"
|
||||
description: Tag for the Docker image
|
||||
required: true
|
||||
default: "test"
|
||||
default: test
|
||||
|
||||
env:
|
||||
REPO: kerberos/agent
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
build-amd64:
|
||||
runs-on: ubuntu-24.04
|
||||
release:
|
||||
permissions:
|
||||
contents: write
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [amd64]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: agent-${{matrix.architecture}}.tar
|
||||
path: agent-${{matrix.architecture}}.tar
|
||||
|
||||
build-arm64:
|
||||
runs-on: ubuntu-24.04-arm
|
||||
permissions:
|
||||
contents: write
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [arm64]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: agent-${{matrix.architecture}}.tar
|
||||
path: agent-${{matrix.architecture}}.tar
|
||||
|
||||
create-manifest:
|
||||
runs-on: ubuntu-24.04
|
||||
needs: [build-amd64, build-arm64]
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKER_USERNAME }}
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Create and push multi-arch manifest
|
||||
run: |
|
||||
docker manifest create $REPO:${{ github.event.inputs.tag || github.ref_name }} \
|
||||
$REPO-arch:arch-amd64-${{github.event.inputs.tag || github.ref_name}} \
|
||||
$REPO-arch:arch-arm64-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker manifest push $REPO:${{ github.event.inputs.tag || github.ref_name }}
|
||||
- name: Create and push latest manifest
|
||||
run: |
|
||||
docker manifest create $REPO:latest \
|
||||
$REPO-arch:arch-amd64-${{github.event.inputs.tag || github.ref_name}} \
|
||||
$REPO-arch:arch-arm64-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker manifest push $REPO:latest
|
||||
if: github.event.inputs.tag == 'test'
|
||||
|
||||
create-release:
|
||||
runs-on: ubuntu-24.04
|
||||
needs: [build-amd64, build-arm64]
|
||||
permissions:
|
||||
contents: write
|
||||
steps:
|
||||
- name: Download all artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
- name: Create a release
|
||||
uses: ncipollo/release-action@v1
|
||||
with:
|
||||
latest: true
|
||||
allowUpdates: true
|
||||
name: ${{ github.event.inputs.tag || github.ref_name }}
|
||||
tag: ${{ github.event.inputs.tag || github.ref_name }}
|
||||
generateReleaseNotes: false
|
||||
omitBodyDuringUpdate: true
|
||||
artifacts: "agent-*.tar/agent-*.tar"
|
||||
id-token: write
|
||||
uses: ./.github/workflows/image-release.yml
|
||||
with:
|
||||
tag: ${{ inputs.tag || github.event.release.tag_name }}
|
||||
source_ref: ${{ github.event_name == 'release' && format('refs/tags/{0}', github.event.release.tag_name) || github.sha }}
|
||||
publish_latest: ${{ github.event_name == 'workflow_dispatch' && inputs.tag == 'test' }}
|
||||
secrets: inherit
|
||||
|
||||
+42
-39
@@ -1,6 +1,6 @@
|
||||
|
||||
ARG GO_IMAGE=golang:1.25-trixie
|
||||
ARG RUNTIME_IMAGE=debian:trixie-slim
|
||||
ARG GO_IMAGE=golang:1.26.10-trixie@sha256:a050dcceee6eb9bf110151662dfac7662f3bec40927c7dee48731e3d92083d42
|
||||
ARG RUNTIME_IMAGE=debian:trixie-slim@sha256:f6b08b09a05725f9431502d3b5714f5c4576e82c1a84fa1debe0c24a7e0c3ec4
|
||||
ARG VERSION=0.0.0
|
||||
FROM ${GO_IMAGE} AS build-machinery
|
||||
LABEL AUTHOR=uug.ai
|
||||
@@ -14,12 +14,13 @@ ARG TARGETARCH
|
||||
ENV GOROOT=/usr/local/go
|
||||
ENV GOPATH=/go
|
||||
ENV PATH=$GOPATH/bin:$GOROOT/bin:/usr/local/lib:$PATH
|
||||
ENV GOSUMDB=off
|
||||
ENV GOTOOLCHAIN=local
|
||||
ENV CGO_ENABLED=1
|
||||
|
||||
##########################################
|
||||
# Installing some additional dependencies.
|
||||
|
||||
RUN apt-get update && apt-get install -y --fix-missing --no-install-recommends \
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
git build-essential cmake pkg-config unzip libgtk2.0-dev \
|
||||
curl ca-certificates libavcodec-dev libavutil-dev libcurl4-openssl-dev \
|
||||
libssl-dev libjpeg62-turbo-dev libswscale-dev && \
|
||||
@@ -31,13 +32,12 @@ RUN apt-get update && apt-get install -y --fix-missing --no-install-recommends \
|
||||
RUN mkdir -p /go/src/github.com/kerberos-io/agent
|
||||
WORKDIR /go/src/github.com/kerberos-io/agent/machinery
|
||||
COPY machinery/go.mod machinery/go.sum ./
|
||||
RUN go mod download
|
||||
RUN go version && go mod download && go mod verify
|
||||
|
||||
##############################################################################
|
||||
# Copy the rest of the source after dependencies are primed.
|
||||
|
||||
COPY machinery ./
|
||||
RUN rm -rf .env
|
||||
|
||||
##################
|
||||
# Build Machinery
|
||||
@@ -46,12 +46,13 @@ RUN RESOLVED_VERSION="${VERSION:-0.0.0}" && \
|
||||
printf '%s' "${RESOLVED_VERSION}" > version && \
|
||||
BUILD_TAGS=timetzdata,netgo,osusergo && \
|
||||
case "${TARGETARCH:-$(go env GOARCH)}" in amd64|arm64) BUILD_TAGS="moq,${BUILD_TAGS}" ;; esac && \
|
||||
go build -o main -tags "${BUILD_TAGS}" --ldflags "-s -w -X github.com/kerberos-io/agent/machinery/src/utils.VERSION=${RESOLVED_VERSION}" . && \
|
||||
go build -mod=readonly -trimpath -buildvcs=false -o main -tags "${BUILD_TAGS}" --ldflags "-s -w -X github.com/kerberos-io/agent/machinery/src/utils.VERSION=${RESOLVED_VERSION}" . && \
|
||||
mkdir -p /agent && \
|
||||
mv main /agent && \
|
||||
mv version /agent && \
|
||||
mv data /agent && \
|
||||
mkdir -p /agent/data/cloud && \
|
||||
mkdir -p /agent/data/tus && \
|
||||
mkdir -p /agent/data/snapshots && \
|
||||
mkdir -p /agent/data/log && \
|
||||
mkdir -p /agent/data/recordings && \
|
||||
@@ -70,7 +71,7 @@ RUN cp -r /agent ./
|
||||
|
||||
RUN /dist/agent/main version
|
||||
|
||||
FROM node:22-alpine AS build-ui
|
||||
FROM node:22-alpine@sha256:fe4f6d74e20370acb04ad889077d14d0f64a9c8ea6a42bc60cddf1e844699914 AS build-ui
|
||||
|
||||
RUN apk update && apk upgrade --available && sync
|
||||
|
||||
@@ -94,59 +95,61 @@ RUN mkdir -p ./agent && cp -r /go/src/github.com/kerberos-io/agent/machinery/www
|
||||
############################################
|
||||
# Publish main binary to GitHub release
|
||||
|
||||
FROM ${RUNTIME_IMAGE}
|
||||
|
||||
############################
|
||||
# Protect by non-root user.
|
||||
FROM ${RUNTIME_IMAGE} AS runtime-rootfs
|
||||
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
ca-certificates curl ffmpeg libatomic1 libcap2-bin libstdc++6 && \
|
||||
rm -rf /var/lib/apt/lists/* && \
|
||||
groupadd --system kerberosio && \
|
||||
useradd --system --gid kerberosio --groups video --create-home agent && \
|
||||
chmod 0755 /home/agent
|
||||
ca-certificates ffmpeg libatomic1 libstdc++6 \
|
||||
dash coreutils findutils grep sed tzdata ncurses-base && \
|
||||
groupadd --system --gid 999 kerberosio && \
|
||||
useradd --system --uid 999 --gid kerberosio --groups video \
|
||||
--home-dir /home/agent --no-create-home agent
|
||||
|
||||
#################################
|
||||
# Copy files from previous images
|
||||
|
||||
COPY --chown=0:0 --from=build-machinery /dist /
|
||||
COPY --chown=0:0 --from=build-ui /dist /
|
||||
COPY --chown=0:0 --from=build-machinery /dist/agent/ /runtime/home/agent/
|
||||
COPY --chown=0:0 --from=build-ui /dist/agent/ /runtime/home/agent/
|
||||
COPY deployments/docker/assemble-rootfs.sh /usr/local/bin/assemble-rootfs
|
||||
|
||||
##################
|
||||
# Try running agent
|
||||
RUN chmod 0755 /runtime/home/agent /runtime/home/agent/main && \
|
||||
cp /runtime/home/agent/data/config/config.json /runtime/home/agent/data/config.template.json && \
|
||||
chown -R agent:kerberosio /runtime/home/agent/data && \
|
||||
sh /usr/local/bin/assemble-rootfs
|
||||
|
||||
RUN mv /agent/* /home/agent/
|
||||
RUN /home/agent/main version
|
||||
FROM scratch
|
||||
|
||||
#######################
|
||||
# Make template config
|
||||
COPY --from=runtime-rootfs /runtime/ /
|
||||
|
||||
RUN cp /home/agent/data/config/config.json /home/agent/data/config.template.json
|
||||
ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
|
||||
ENV HOME=/home/agent
|
||||
ENV XDG_CACHE_HOME=/tmp/agent-cache
|
||||
ENV AGENT_PORT=8080
|
||||
|
||||
###########################
|
||||
# Set permissions correctly
|
||||
|
||||
RUN chown -R agent:kerberosio /home/agent/data
|
||||
RUN chown -R agent:kerberosio /home/agent/www
|
||||
|
||||
###########################
|
||||
# Grant the necessary root capabilities to the process trying to bind to the privileged port
|
||||
RUN setcap 'cap_net_bind_service=+ep' /home/agent/main
|
||||
ARG VERSION
|
||||
ARG REVISION=unknown
|
||||
ARG CREATED
|
||||
LABEL org.opencontainers.image.title="Kerberos Agent" \
|
||||
org.opencontainers.image.description="Camera and media agent with a minimal dynamic scratch runtime" \
|
||||
org.opencontainers.image.source="https://github.com/kerberos-io/agent" \
|
||||
org.opencontainers.image.version="${VERSION}" \
|
||||
org.opencontainers.image.revision="${REVISION}" \
|
||||
org.opencontainers.image.created="${CREATED}" \
|
||||
org.opencontainers.image.vendor="UUG.AI"
|
||||
|
||||
###################
|
||||
# Run non-root user
|
||||
|
||||
USER agent
|
||||
USER 999:999
|
||||
|
||||
######################################
|
||||
# By default the app runs on port 80
|
||||
# The image uses an unprivileged HTTP port.
|
||||
|
||||
EXPOSE 80
|
||||
EXPOSE 8080/tcp
|
||||
|
||||
######################################
|
||||
# Check if agent is still running
|
||||
|
||||
HEALTHCHECK CMD curl --fail "http://localhost:${AGENT_PORT:-80}/health" || exit 1
|
||||
HEALTHCHECK --timeout=10s CMD ["/home/agent/main", "-action", "healthcheck"]
|
||||
|
||||
###################################################
|
||||
# Leeeeettttt'ssss goooooo!!!
|
||||
|
||||
@@ -134,12 +134,51 @@ lists and automatic cleanup.
|
||||
|
||||
The easiest way to get your Kerberos Agent up and running is to use our public image on [Docker hub](https://hub.docker.com/r/kerberos/agent). Once you have selected a specific tag, run `docker` command below, which will open the web interface of your Kerberos agent on port `80`, and off you go. For a more configurable and persistent deployment have a look at [Running and automating a Kerberos Agent](#running-and-automating-a-kerberos-agent).
|
||||
|
||||
docker run -p 80:80 --name mycamera -d --restart=always kerberos/agent:latest
|
||||
**Forthcoming hardened image** (use this mapping only after upgrading to a
|
||||
release containing these changes):
|
||||
|
||||
docker run -p 80:8080 --name mycamera -d --restart=always kerberos/agent:latest
|
||||
|
||||
The hardened image listens on **8080 inside the container**, not 80. The mapping
|
||||
`-p 80:8080` keeps the browser URL `http://localhost/` unchanged. When upgrading,
|
||||
change the container side of existing `80:80` or `8082:80` mappings to
|
||||
`80:8080` or `8082:8080`. Kubernetes Services must use `targetPort: 8080`.
|
||||
Older published images still use their original port: these examples require a
|
||||
release containing the hardening changes; pin its published digest in production.
|
||||
For the currently published `v3.14.1`, retain the old mapping:
|
||||
|
||||
docker run -p 80:80 --name mycamera -d --restart=always kerberos/agent:v3.14.1
|
||||
|
||||
The image uses a Go 1.26 scratch runtime with only required dynamic/media
|
||||
dependencies, numeric non-root UID/GID `999:999`, no file capabilities or
|
||||
setuid/setgid programs, and an application healthcheck (no curl-based probe).
|
||||
UI assets are immutable; demo mode selects its environment without rewriting them.
|
||||
Source builds require the patched Go 1.26.10 toolchain or newer.
|
||||
It supports dropping all capabilities and preventing privilege escalation:
|
||||
|
||||
```sh
|
||||
docker run --cap-drop=ALL --security-opt=no-new-privileges:true \
|
||||
-p 80:8080 --name mycamera -d kerberos/agent:latest
|
||||
```
|
||||
|
||||
See the [image contract](deployments/docker/README.md#image-contract) for writable
|
||||
paths, health checks, supported architectures, signature/evidence requirements,
|
||||
and release-policy gaps. Functional remote-shell support remains a **pending
|
||||
policy exception**, so this is not a claim of full image-hardening baseline or
|
||||
CIS compliance.
|
||||
Release promotion is also blocked by remaining native-library scan findings;
|
||||
this PR is not release-qualified. The existing recording-signing key and trust
|
||||
behavior are retained under the user's narrowly scoped exception through
|
||||
December 5, 2026 (23:59:59 UTC), recorded for review in this PR. The finding
|
||||
remains visible in scan reports; other keys and findings are not exempted.
|
||||
|
||||
If you want to connect to a USB or Raspberry Pi camera, [you'll need to run our side car container](https://github.com/kerberos-io/camera-to-rtsp) which proxies the camera to an RTSP stream. In that case you'll want to configure the Kerberos Agent container to run in the host network, so it can connect directly to the RTSP sidecar.
|
||||
|
||||
docker run --network=host --name mycamera -d --restart=always kerberos/agent:latest
|
||||
|
||||
With host networking, no port mapping applies: the hardened Agent is reachable
|
||||
on host port `8080` by default.
|
||||
|
||||
## Quickstart - Balena
|
||||
|
||||
Run Kerberos Agent with [Balena Cloud](https://www.balena.io/) super powers. Monitor your Kerberos Agent with seamless remote access, over the air updates, an encrypted public `https` endpoint and much more. Checkout our application `video-surveillance` on [Balena Hub](https://hub.balena.io/apps/2064752/video-surveillance), and create your first or fleet of Kerberos Agent(s).
|
||||
@@ -168,7 +207,7 @@ This repository contains everything you'll need to know about our core product,
|
||||
|
||||
- Low memory and CPU usage.
|
||||
- Simplified and modern user interface.
|
||||
- Multi architecture (ARMv6, ARMv7, ARM64, AMD64)
|
||||
- Multi architecture (AMD64/ARM64 release images; [legacy ARM build limitations](deployments/docker/README.md#building-and-checking-the-image)).
|
||||
- Multi stream, for example recording in H265, live streaming and motion detection in H264.
|
||||
- Multi camera support: IP Cameras (H264 and H265), USB cameras and Raspberry Pi Cameras [through a RTSP proxy](https://github.com/kerberos-io/camera-to-rtsp).
|
||||
- Single camera per instance (e.g. one container per camera).
|
||||
@@ -221,21 +260,26 @@ An example of how to mount a host directory is shown below using `docker`, but i
|
||||
|
||||
You attach a volume to your container by leveraging the `-v` option. To mount your own configuration file and recordings folder, run the following commands:
|
||||
|
||||
docker run -p 80:80 --name mycamera \
|
||||
docker run -p 80:8080 --name mycamera \
|
||||
-v $(pwd)/agent/config:/home/agent/data/config \
|
||||
-v $(pwd)/agent/recordings:/home/agent/data/recordings \
|
||||
-d --restart=always kerberos/agent:latest
|
||||
|
||||
More examples for each deployment and automation tool [can be found in the deployment section](https://github.com/kerberos-io/agent/tree/master/deployments). Be sure to verify the permissions of the directory/volume you are attaching. More information in [this issue](https://github.com/kerberos-io/agent/issues/80).
|
||||
|
||||
chmod -R 755 kerberos-agent/
|
||||
chown 100:101 kerberos-agent/ -R
|
||||
The current image runs as UID `999`, GID `999`. Give that user ownership of
|
||||
the mounted directories (older image tags may use different IDs):
|
||||
|
||||
sudo chown -R 999:999 agent/config agent/recordings
|
||||
|
||||
See [container permissions and hardening](deployments/docker/README.md#container-permissions-and-hardening)
|
||||
for reduced-capability deployment and migration guidance.
|
||||
|
||||
## Configure with environment variables
|
||||
|
||||
Next to attaching the configuration file, it is also possible to override the configuration with environment variables. This makes deploying with `docker compose` or `kubernetes` much easier and more scalable. Using this approach, we simplify automation through `ansible` and `terraform`.
|
||||
|
||||
docker run -p 80:80 --name mycamera \
|
||||
docker run -p 80:8080 --name mycamera \
|
||||
-e AGENT_NAME=mycamera \
|
||||
-e AGENT_TIMEZONE=Europe/Brussels \
|
||||
-e AGENT_CAPTURE_IPCAMERA_RTSP=rtsp://fake.kerberos.io/stream \
|
||||
@@ -358,7 +402,7 @@ See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI,
|
||||
| --------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------ |
|
||||
| `LOG_LEVEL` | Level for logging, could be "info", "warning", "debug", "error" or "fatal". | "info" |
|
||||
| `LOG_OUTPUT` | Logging output format "json" or "text". | "text" |
|
||||
| `AGENT_PORT` | HTTP web server port. Overrides the `-port` command-line value and must be between 1 and 65535. | "80" |
|
||||
| `AGENT_PORT` | HTTP web server port. Overrides `-port`; use a port above 1024 in the hardened image. | "8080" hardened Docker; "80" legacy images/binaries |
|
||||
| `AGENT_MODE` | You can choose to run this in 'release' for production, and or 'demo' for showcasing. | "release" |
|
||||
| `AGENT_TLS_INSECURE` | Specify if you want to use `InsecureSkipVerify` for the internal HTTP client. | "false" |
|
||||
| `AGENT_USERNAME` | The username used to authenticate against the Kerberos Agent login page. | "root" |
|
||||
@@ -502,7 +546,7 @@ The value must be valid JSON on a single line, so wrap it in single quotes in a
|
||||
shell:
|
||||
|
||||
```bash
|
||||
docker run -p 80:80 --name mycamera \
|
||||
docker run -p 80:8080 --name mycamera \
|
||||
-e AGENT_CLOUD=kstorage \
|
||||
-e AGENT_KERBEROSVAULT_URI=https://vault.domain.com/api \
|
||||
-e AGENT_KERBEROSVAULT_ACCESS_KEY=xxx \
|
||||
@@ -643,7 +687,7 @@ Go and open two terminals: one for the `ui` project and one for the `machinery`
|
||||
1. Terminal A:
|
||||
|
||||
cd machinery/
|
||||
go run main.go -action run -port 80
|
||||
go run . -action run -port 80
|
||||
|
||||
2. Terminal B:
|
||||
|
||||
@@ -687,7 +731,7 @@ You can simply run the `machinery` using following commands.
|
||||
|
||||
git clone https://github.com/kerberos-io/agent
|
||||
cd machinery
|
||||
go run main.go -action run -port 8082
|
||||
go run . -action run -port 8082
|
||||
|
||||
This will launch the Kerberos Agent and run a webserver on port `8082`, matching
|
||||
the UI development default. You can change the port together with
|
||||
@@ -732,7 +776,7 @@ The standard AMD64 and ARM64 images include the optional MoQ publisher. Its Rust
|
||||
FFI archive requires CGO and glibc 2.38 or newer, which is why the standard image
|
||||
uses Debian Trixie. The publisher is disabled unless explicitly enabled at runtime:
|
||||
|
||||
docker run --rm -p 80:80 \
|
||||
docker run --rm -p 80:8080 \
|
||||
-e AGENT_LIVE_MOQ_ENABLED=true \
|
||||
-e AGENT_LIVE_MOQ_URL=https://relay.uug.ai/anon \
|
||||
kerberos/agent
|
||||
|
||||
@@ -2,6 +2,17 @@
|
||||
|
||||
Kubernetes is great, but you might love OpenShift even more. In this directory you'll find some resources to deploy your Kerberos Agent in an OpenShift cluster using Ansible playbook. We'll review the different tasks of the Ansible playbook step by step; find the complete `playbook.yaml` here.
|
||||
|
||||
The playbook's port mapping targets the forthcoming hardened image:
|
||||
`containerPort: 8080` and `targetPort: 8080`, with external Service port `80`
|
||||
unchanged. Previously published images, including `v3.14.1`, still need the old
|
||||
container port 80. Upgrade the image and mapping together and pin its published
|
||||
digest. See the [image contract](../docker/README.md#image-contract) for numeric
|
||||
UID/GID `999:999`, writable data/cache paths and release blockers. OpenShift SCCs
|
||||
may override the UID; provision matching volume permissions and verify your
|
||||
cluster's policy rather than granting privileged access. This legacy playbook's
|
||||
credential-debugging/certificate-validation settings also require production
|
||||
review; the image/port update does not certify the cluster deployment.
|
||||
|
||||
## Variabeles
|
||||
|
||||
We'll have a few `variables` in our `playbook.yml` that will help us to setup secure connection with the OpenShift cluster. We need the `cluster_url` and the `username` and `password` of the OpenShift cluster. If you don't know where to find this, you can find this in the OpenShift web ui.
|
||||
|
||||
@@ -111,7 +111,7 @@
|
||||
mountPath: /home/agent/data/cloud
|
||||
subPath: cloud
|
||||
ports:
|
||||
- containerPort: 80
|
||||
- containerPort: 8080
|
||||
protocol: TCP
|
||||
|
||||
- name: Expose Kerberos Agent
|
||||
@@ -136,5 +136,5 @@
|
||||
ports:
|
||||
- name: http
|
||||
port: 80
|
||||
targetPort: 80
|
||||
targetPort: 8080
|
||||
protocol: TCP
|
||||
|
||||
@@ -4,17 +4,258 @@ The easiest, and let's say most natural, deployment is done [by utilising `docke
|
||||
|
||||
## 1. Running a single container
|
||||
|
||||
We are creating Docker images as part of our CI/CD process. You'll find our Docker images on [Docker hub](https://hub.docker.com/r/kerberos/agent). Pick a specific tag of choice, or use latest. Once done run below command, this will open the web interface of your Kerberos agent on port 80.
|
||||
We publish production images on [Docker Hub](https://hub.docker.com/r/kerberos/agent).
|
||||
The following examples target the forthcoming hardened image, which listens on
|
||||
**8080 inside the container**. They preserve host port 80 and the browser URL
|
||||
`http://localhost/`:
|
||||
|
||||
docker run -p 80:80 --name mycamera -d kerberos/agent:latest
|
||||
docker run -p 80:8080 --name mycamera -d kerberos/agent:latest
|
||||
|
||||
Or for a develop build:
|
||||
**Migration:** releases published before this change, including `v3.14.1`, still
|
||||
listen on container port 80 and require `-p 80:80`. Do not change their mappings
|
||||
until upgrading the image too. The separate `kerberos/agent-dev` image is not
|
||||
migrated by this production-image change:
|
||||
|
||||
docker run -p 80:80 --name mycamera -d kerberos/agent-dev:latest
|
||||
|
||||
Feel free to use another port if your host system already has a workload running on `80`. For example `8082`.
|
||||
|
||||
docker run -p 8082:80 --name mycamera -d kerberos/agent:latest
|
||||
docker run -p 8082:8080 --name mycamera -d kerberos/agent:latest
|
||||
|
||||
## Image contract
|
||||
|
||||
This contract describes the hardened production Dockerfile, not an already
|
||||
published release or a claim of full
|
||||
[image-hardening baseline](https://learn.uug.ai/guides/security/image-hardening/)
|
||||
compliance. Use a release's actual published multi-platform digest, for example
|
||||
`kerberos/agent:<version>@sha256:<digest>`, rather than treating mutable `latest`
|
||||
as immutable. No new release digest or signature is asserted by this PR.
|
||||
|
||||
| Property | Contract |
|
||||
|---|---|
|
||||
| Identity | Fixed numeric `USER 999:999`, account `agent`, primary group `kerberosio`; not root and no privilege-changing startup. |
|
||||
| Startup | Working directory `/home/agent`; exec-form default command `./main -action run`. Standalone binary CLI defaults remain unchanged. |
|
||||
| Inbound HTTP | TCP `8080`, configurable with `AGENT_PORT` (overrides `-port`). Use an unprivileged port. Map host `80:8080`, or Service port `80` to `targetPort: 8080`. Terminate inbound TLS at a trusted proxy; the default listener is HTTP. |
|
||||
| Privileges | No bundled setuid/setgid programs or file capabilities. Run with all capabilities dropped and `no-new-privileges`; no `NET_BIND_SERVICE` is required. |
|
||||
| Writable application paths | Only `/home/agent/data/` (configuration, recordings, snapshots, cloud, tus checkpoints, capture tests and logs). Binary, UI assets and application home remain root-owned/read-only to UID 999. Demo mode serves its environment without rewriting UI assets. |
|
||||
| Temporary state | `/tmp`, `/var/tmp`; user font/media caches under `XDG_CACHE_HOME=/tmp/agent-cache`, owned by `999:999` with mode `0700`. Recreate that directory with these permissions when mounting a fresh tmpfs over `/tmp`. |
|
||||
| Health | Exec `/home/agent/main -action healthcheck`; five-second bounded localhost `/health` probe on the resolved port, no proxy/redirects, validates the Agent JSON envelope, exits nonzero on failure. Docker timeout is ten seconds. |
|
||||
| Readiness and metrics | `/health` is HTTP liveness, not proof of camera, MQTT or Hub readiness. Camera/Hub details are diagnostic. This image does not add a Prometheus metrics listener. |
|
||||
| Certificates/time | Debian CA bundle, OpenSSL configuration and timezone data retained. Mount a prepared CA bundle read-only and use `SSL_CERT_FILE` where appropriate for Go clients; native FFmpeg/OpenSSL clients may require their own CA configuration. Do not disable TLS verification as a substitute. |
|
||||
| Secrets | Inject application credentials/keys at runtime using the orchestrator's existing environment/configuration mechanisms. Change default credentials before exposing HTTP. Never build production config, `.env`, private keys or registry credentials into an image. No new generic `*_FILE` interface is provided. |
|
||||
| Outbound traffic | Configured RTSP/RTSPS/ONVIF camera endpoints, MQTT, Hub/Vault/storage HTTPS endpoints, DNS and optional telemetry; WebRTC may require configured STUN/TURN and negotiated UDP/TCP connectivity. Apply an allowlist suited to the actual enabled integrations. |
|
||||
| Architecture | Native AMD64 and ARM64 build/runtime checks; ARMv7 remains a legacy build target needing its own evidence. ARMv6 is blocked by the default builder manifest; see below. |
|
||||
|
||||
### Container permissions and hardening
|
||||
|
||||
The final image uses `FROM scratch` with an explicitly assembled Debian/glibc
|
||||
runtime rather than the whole Debian filesystem. FFmpeg and its required native
|
||||
libraries/plugins remain for camera/media functionality, including AAC-to-PCMU.
|
||||
Apt/dpkg executables, account/capability-management tools, curl, and bundled
|
||||
setuid/setgid permissions are absent. An application subcommand, not shell/curl,
|
||||
implements the healthcheck.
|
||||
|
||||
```sh
|
||||
docker run --cap-drop=ALL --security-opt=no-new-privileges:true \
|
||||
-p 80:8080 --name mycamera -d kerberos/agent:latest
|
||||
```
|
||||
|
||||
Do not use `--privileged` for ordinary IP cameras. Local cameras still use the
|
||||
separate RTSP sidecar; any device access belongs to that sidecar. Host networking
|
||||
remains supported, but without a mapping the Agent is reachable on host port
|
||||
`8080`, not 80.
|
||||
|
||||
The numeric `USER 999:999` does **not** automatically inherit supplementary video
|
||||
membership from `/etc/group`. If a deployment deliberately passes a video device
|
||||
to Agent, explicitly add the device's host GID: `--group-add 44` for GID 44,
|
||||
Compose `group_add: ["44"]`, or Kubernetes `supplementalGroups: [44]`. The runtime
|
||||
retains the `video` group record. Match the actual device permissions; this does
|
||||
not grant arbitrary device access or replace the separate local-camera sidecar.
|
||||
|
||||
**Pending policy exception:** functional remote terminal sessions require
|
||||
`/bin/sh`, PTY devices, terminal data and basic GNU utilities. These remain for
|
||||
that feature, not healthchecks or debugging convenience. The user chose to
|
||||
preserve the feature, but no policy approver, exception owner or expiry has been
|
||||
provided. This is not an approved waiver or full baseline/CIS compliance.
|
||||
Baseline-qualified release promotion must remain blocked until the exception is
|
||||
formally resolved; do not silently remove the feature or manufacture approval.
|
||||
|
||||
Bind mounts must be writable by the image's UID/GID; the container does not
|
||||
change host ownership at startup. Before migrating an older volume, check the
|
||||
user of the exact old and new image with `docker run --rm --entrypoint id IMAGE`
|
||||
and adjust only the mounted directories as necessary. For example:
|
||||
|
||||
```sh
|
||||
sudo chown -R 999:999 agent/config agent/recordings
|
||||
```
|
||||
|
||||
A read-only root filesystem is not enabled by default: `data/` needs initialized
|
||||
writable storage (and FFmpeg or shell sessions may need `/tmp` and `/var/tmp`).
|
||||
Empty bind mounts hide packaged configuration/media files; initialize
|
||||
them before use. Docker named volumes populate packaged contents on first use.
|
||||
Customers enabling read-only root must supply those writable mounts and cache
|
||||
ownership, keep the runtime's device/PTY mounts, and validate their enabled media
|
||||
and remote-access features. Apply CPU/memory/PID limits, seccomp/AppArmor and
|
||||
network policies appropriate to the deployment.
|
||||
|
||||
### Building and checking the image
|
||||
|
||||
Build from a clean checkout: the default configuration files under
|
||||
`machinery/data/config/` are included in the image, so do not replace them with
|
||||
production credentials before building. `.dockerignore` excludes local `.env`
|
||||
files, credential directories/configuration, test/profiling outputs, recordings,
|
||||
upload checkpoints, dependency directories, and unrelated
|
||||
repository files from the build context. The builder uses Go `1.26.10` with
|
||||
`GOTOOLCHAIN=local`, checksum database verification, and `go mod verify`. Builds
|
||||
use `-mod=readonly` to reject implicit module changes, `-trimpath` to omit local
|
||||
source paths, and `-buildvcs=false` to omit checkout metadata. CGO remains enabled
|
||||
for the native camera/media dependencies.
|
||||
|
||||
Source builds require at least Go 1.26.10, matching the pinned security patch floor.
|
||||
The Go, Node, and Debian bases are pinned to verified multi-platform manifest
|
||||
digests, including AMD64 and ARM64 (and ARMv7 where previously supported).
|
||||
The pinned Debian image is used only to assemble the scratch runtime with
|
||||
glibc-compatible FFmpeg, CGO, and MoQ dependencies. Its native package dependency
|
||||
metadata selects the architecture's dynamic loader, shared libraries, media
|
||||
plugins/drivers, and associated data files. This is intentionally broader than
|
||||
an `ldd`-only copy, which misses dynamically loaded plugins. Certificates,
|
||||
OpenSSL configuration, time zones, font/MIME/pixbuf caches, account records, and
|
||||
standard writable `/tmp` and device mount points are retained. The runtime
|
||||
uses `XDG_CACHE_HOME=/tmp/agent-cache` for disposable user caches without making
|
||||
the application home writable. It contains package provenance in
|
||||
`/var/lib/dpkg/status` and license notices, but
|
||||
not the package manager. Update it by rebuilding and replacing the image rather
|
||||
than installing packages in a running container.
|
||||
|
||||
```sh
|
||||
docker build --pull -t kerberos/agent:local .
|
||||
sh deployments/docker/test-image.sh kerberos/agent:local
|
||||
```
|
||||
|
||||
The smoke check uses temporary containers and a Docker volume, cleans them up,
|
||||
and checks permissions, FFmpeg audio transcoding, H264/sample-video decoding,
|
||||
H265 encoding/decoding, font rendering, shell/PTY devices, volume
|
||||
initialization/writes, default and custom HTTP ports, health probes, and
|
||||
demo-mode startup with a read-only root and immutable UI assets. It enforces
|
||||
privileged low ports while running on 8080 with no capabilities and
|
||||
`no-new-privileges`, and also checks an overridden port `8082`. PR builds
|
||||
run it on native AMD64 and ARM64 runners. It does not replace testing against a
|
||||
real camera, hardware codecs/devices, an MQTT-mediated remote shell session, or
|
||||
all supported ARM variants. Review and refresh the
|
||||
base-image digests regularly for security updates; `--pull` alone does not update
|
||||
a pinned digest. `GO_IMAGE` and `RUNTIME_IMAGE` remain overrideable build arguments
|
||||
for compatible alternatives. The package repositories are not snapshot-pinned,
|
||||
so base digest pins do not make the entire build bit-for-bit reproducible.
|
||||
|
||||
Architecture selections are unchanged by this hardening.
|
||||
The pinned `golang:1.26.10-trixie` manifest, like the previous Go 1.25 trixie base,
|
||||
has no `linux/arm/v6` variant, so the existing ARMv6 nightly target cannot be
|
||||
validated with the default base.
|
||||
ARMv6 needs a separately reviewed compatible builder/runtime combination; do
|
||||
not assume an ARMv7 image runs on ARMv6 hardware.
|
||||
|
||||
### Release evidence, vulnerabilities and lifecycle
|
||||
|
||||
The hardened release path must build/test the supported release architectures,
|
||||
block HIGH/CRITICAL vulnerability/secret/misconfiguration findings, retain scan
|
||||
reports and an SBOM, publish build provenance, and sign the **final
|
||||
multi-platform index digest**, not just one child manifest. A pending policy
|
||||
exception is not an approved scan exception. There are no approved
|
||||
vulnerability exceptions in this change; findings require remediation or a
|
||||
reviewed owner/expiry/approval record. Scanner/database failures must fail
|
||||
closed. Workflow definitions are not evidence that registry publication,
|
||||
signing, or scans have already succeeded.
|
||||
|
||||
Source scans cover UI production **and build/development** dependencies and retain
|
||||
their application inventory/SBOM, because compiled browser assets hide lockfile
|
||||
metadata from final-rootfs scanners. Final-image evidence separately covers native
|
||||
packages and the Go binary. Current native-library findings remain release
|
||||
blockers. The existing embedded recording-signing key and trust behavior are
|
||||
retained under the user's time-limited source-secret exception, recorded for
|
||||
review in this PR in
|
||||
[image-scan-exceptions.json](../../.github/scripts/image-scan-exceptions.json).
|
||||
Owner and approver: `@cedricve`; expiry: **December 5, 2026, 23:59:59 UTC**.
|
||||
Anyone possessing this shared private key can forge signatures under its
|
||||
identity; the exception accepts that risk temporarily, it does not fix it.
|
||||
|
||||
The exception matches only that source file's SHA-256, exact scanner rule,
|
||||
category, HIGH severity and line location, and requires exactly one match.
|
||||
Changes, missing/incomplete approval, expiry or duplicate findings fail closed.
|
||||
It cannot exempt an image finding, another secret, a vulnerability or a
|
||||
misconfiguration. The policy is loaded from the executing workflow's checkout,
|
||||
not the source directory being scanned. Retained `scan.json` still contains the
|
||||
redacted HIGH finding; `exception-policy.json`, `exception-decisions.json` and
|
||||
`policy.json` record the approval/application, without key material. Review the
|
||||
record in PR #350 before merging; repository owners must enforce required reviews.
|
||||
This exception does not approve the separate pending remote-terminal policy.
|
||||
|
||||
The build jobs run compilation and production-image smoke tests before the
|
||||
security gates. A job that fails at **Source/UI dependency and final image gates
|
||||
with SPDX SBOMs** is not a compiler or startup failure; inspect its retained
|
||||
reports rather than disabling the gate. Patched Go dependencies are checked
|
||||
with `govulncheck` as well as the image/source scanner. The pinned
|
||||
`golang.org/x/crypto` revision is the official reviewed OpenPGP module split
|
||||
for [GO-2026-5932](https://pkg.go.dev/vuln/GO-2026-5932); Agent does not import the
|
||||
retired OpenPGP packages.
|
||||
|
||||
Debian 13 stable, security and backports currently provide no patched FFmpeg
|
||||
7.1.x or libxml2 packages for the blocking findings on either AMD64 or ARM64.
|
||||
For example, Debian defers [CVE-2026-58049](https://security-tracker.debian.org/tracker/CVE-2026-58049)
|
||||
until an upstream 7.1.x fix; a fix exists in FFmpeg 9. A Wolfi FFmpeg 7 prototype
|
||||
had no vendor-scanner findings but still used the same affected upstream
|
||||
7.1.5 code and lacked the existing hardware accelerators. It was **not**
|
||||
adopted to obtain a misleading clean scan. A newer media stack needs matched
|
||||
CGO headers/libraries and validation of codecs, hardware acceleration and
|
||||
supported architectures, not an unreviewed mix of testing-distribution packages.
|
||||
The user has chosen to keep the default recording-signing key; no trust
|
||||
migration or startup change is implemented. Its source-secret finding becomes
|
||||
release-blocking again if the scoped exception expires or no longer matches.
|
||||
Any future removal would require a separately
|
||||
authorized migration: per-installation keys need verifier/public-key provisioning,
|
||||
while requiring an injected key changes startup for existing keyless installations.
|
||||
|
||||
Before deploying, obtain the release's digest, source revision, supported
|
||||
platforms, per-platform SBOM/scan reports, provenance, signature certificate
|
||||
identity and policy approvals from its retained release evidence. Verify the
|
||||
signature against the **exact trusted workflow identity** and GitHub OIDC issuer,
|
||||
not an unrestricted identity regexp:
|
||||
|
||||
Workflow artifacts `image-source-evidence` and `image-final-evidence` retain
|
||||
sanitized reports, source/application and per-platform SBOMs, provenance, base
|
||||
digests and the source revision for 90 days. Successful releases also attach
|
||||
`image-security-evidence.tar.gz`. After successful signing,
|
||||
`signing-identity.txt` records the exact
|
||||
`https://github.com/kerberos-io/agent/.github/workflows/image-release.yml@...`
|
||||
identity; the suffix is the executing workflow ref, not necessarily the source
|
||||
ref. Require the expected trusted ref, not merely any identity found in an
|
||||
artifact. Secret matches/source excerpts are redacted; findings are not waived.
|
||||
|
||||
```sh
|
||||
# Set these from the trusted release's real evidence, not from this example.
|
||||
cosign verify --certificate-identity="$COSIGN_IDENTITY" \
|
||||
--certificate-oidc-issuer=https://token.actions.githubusercontent.com \
|
||||
"$AGENT_IMAGE"
|
||||
```
|
||||
|
||||
`AGENT_IMAGE` must contain the immutable registry digest. Reject missing,
|
||||
mismatched, expired or unapproved evidence; neither a successful local build nor
|
||||
`FROM scratch` certifies the image is vulnerability-free. Registry credentials,
|
||||
OIDC permissions and repository release protections must be configured by the
|
||||
repository owner; this PR does not invent them or certify those external controls.
|
||||
|
||||
Review pinned digests and native/package/module findings for every release and
|
||||
regularly between releases. Debian 13 has
|
||||
[full support until August 9, 2028 and LTS until June 30, 2030](https://www.debian.org/releases/trixie/),
|
||||
with reduced LTS architecture/package coverage. The Go 1.26 line is supported
|
||||
[until two newer major Go releases exist](https://go.dev/doc/devel/release#policy);
|
||||
update its patch pin and replace it before that boundary. The build-only Node 22
|
||||
line has [scheduled EOL April 30, 2027](https://github.com/nodejs/Release/blob/main/schedule.json).
|
||||
The pinned UI builder is Node `22.23.4` on Alpine `3.24.3`;
|
||||
[Alpine 3.24 main support ends June 1, 2028](https://alpinelinux.org/releases/),
|
||||
while community support ends at the next stable release. Track both when
|
||||
refreshing that build-only base. Rebuilding does not refresh immutable
|
||||
base pins automatically, and APT repositories are not snapshot-pinned. Retain the
|
||||
actual installed-package/SBOM evidence per architecture and release.
|
||||
|
||||
### Attach a volume
|
||||
|
||||
@@ -34,7 +275,7 @@ You attach a volume to your container by leveraging the `-v` option. To mount yo
|
||||
|
||||
3. Run the docker command as following to attach your config directory and recording directory.
|
||||
|
||||
docker run -p 80:80 --name mycamera \
|
||||
docker run -p 80:8080 --name mycamera \
|
||||
-v $(pwd)/agent/config:/home/agent/data/config \
|
||||
-v $(pwd)/agent/recordings:/home/agent/data/recordings \
|
||||
-d --restart=always kerberos/agent:latest
|
||||
@@ -52,7 +293,7 @@ You'll find [an example `docker-compose.yaml` file here](https://github.com/kerb
|
||||
kerberos-agent2:
|
||||
image: "kerberos/agent:latest"
|
||||
ports:
|
||||
- "8082:80"
|
||||
- "8082:8080"
|
||||
environment:
|
||||
- AGENT_NAME=agent2
|
||||
- AGENT_CAPTURE_IPCAMERA_RTSP=rtsp://x.x.x.x:554/Streaming/Channels/101
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
root=/runtime
|
||||
mkdir -p "$root/usr/bin" "$root/usr/sbin" "$root/usr/lib" "$root/etc" \
|
||||
"$root/var/lib/dpkg" "$root/dev/pts" "$root/proc" "$root/sys" "$root/run"
|
||||
ln -s usr/bin "$root/bin"
|
||||
ln -s usr/sbin "$root/sbin"
|
||||
ln -s usr/lib "$root/lib"
|
||||
if [ -L /lib64 ]; then
|
||||
mkdir -p "$root/usr/lib64"
|
||||
ln -s usr/lib64 "$root/lib64"
|
||||
fi
|
||||
|
||||
# Package dependencies include dlopen-loaded codecs/drivers and their data, which
|
||||
# ldd alone cannot discover. Debian resolves the native architecture's loader too.
|
||||
apt-cache depends --recurse --installed --no-recommends --no-suggests \
|
||||
--no-conflicts --no-breaks --no-replaces --no-enhances \
|
||||
ffmpeg libatomic1 libstdc++6 dash coreutils findutils grep sed tzdata ncurses-base \
|
||||
> /tmp/runtime-dependencies
|
||||
sed -n '/^[a-z0-9][a-z0-9+.:_-]*$/p' /tmp/runtime-dependencies \
|
||||
| grep -vx debconf | sort -u > /tmp/runtime-candidates
|
||||
dpkg-query -W -f='${Package} ${db:Status-Status}\n' > /tmp/package-status
|
||||
awk '$2 == "installed" { print $1 }' /tmp/package-status \
|
||||
| sort -u > /tmp/installed-packages
|
||||
comm -12 /tmp/runtime-candidates /tmp/installed-packages > /tmp/runtime-packages
|
||||
|
||||
set --
|
||||
while IFS= read -r package; do
|
||||
set -- "$@" "$package"
|
||||
done < /tmp/runtime-packages
|
||||
dpkg-query -L "$@" > /tmp/runtime-package-paths
|
||||
sort -u /tmp/runtime-package-paths > /tmp/runtime-paths
|
||||
while IFS= read -r path; do
|
||||
case "$path" in
|
||||
"") continue ;;
|
||||
/usr/share/doc/*/copyright|/usr/share/common-licenses/*) ;;
|
||||
/usr/share/doc/*|/usr/share/man/*|/usr/share/info/*|/usr/share/locale/*|\
|
||||
/usr/share/lintian/*|/usr/share/bug/*|/usr/share/debconf/*|\
|
||||
/usr/share/bash-completion/*|/usr/share/fish/*|\
|
||||
/usr/lib/systemd/*|/lib/systemd/*|/etc/init.d/*|/etc/cron.*/*) continue ;;
|
||||
esac
|
||||
if [ -d "$path" ] && [ ! -L "$path" ]; then
|
||||
continue
|
||||
fi
|
||||
if [ ! -f "$path" ] && [ ! -L "$path" ]; then
|
||||
printf 'Missing selected runtime file: %s\n' "$path" >&2
|
||||
exit 1
|
||||
fi
|
||||
printf '%s\n' "$path"
|
||||
done < /tmp/runtime-paths > /tmp/runtime-files
|
||||
tar --create --file /tmp/runtime.tar --no-recursion --files-from /tmp/runtime-files
|
||||
tar --extract --file /tmp/runtime.tar --directory "$root"
|
||||
|
||||
# Preserve generated trust stores, font configuration/caches and pixbuf loaders.
|
||||
cp -a --parents /etc/ssl /usr/lib/ssl /usr/share/ca-certificates /etc/fonts \
|
||||
/var/cache/fontconfig /usr/share/mime /usr/share/common-licenses "$root"
|
||||
find /usr/lib -path '*/gdk-pixbuf-2.0/*/loaders.cache' \
|
||||
-exec cp -a --parents {} "$root" \;
|
||||
cp -a --parents /etc/nsswitch.conf /etc/gai.conf /etc/localtime \
|
||||
/etc/ld.so.conf /etc/ld.so.conf.d /etc/os-release /etc/debian_version \
|
||||
/usr/lib/os-release /usr/lib/locale "$root"
|
||||
|
||||
# Some public SONAME links (BLAS/LAPACK, for example) are generated by Debian
|
||||
# alternatives rather than owned by a package. Keep only links to selected files.
|
||||
find /usr/lib -type l > /tmp/runtime-links
|
||||
if [ -d /usr/lib64 ]; then
|
||||
find /usr/lib64 -type l >> /tmp/runtime-links
|
||||
fi
|
||||
while IFS= read -r link; do
|
||||
target=$(readlink -f "$link")
|
||||
if [ -e "$root$target" ]; then
|
||||
while [ -L "$link" ]; do
|
||||
cp -a --parents "$link" "$root"
|
||||
target=$(readlink "$link")
|
||||
case "$target" in
|
||||
/*) link=$target ;;
|
||||
*) link=$(dirname "$link")/$target ;;
|
||||
esac
|
||||
done
|
||||
fi
|
||||
done < /tmp/runtime-links
|
||||
|
||||
getent passwd root agent nobody > "$root/etc/passwd"
|
||||
getent group root kerberosio video nogroup > "$root/etc/group"
|
||||
mkdir -p "$root/tmp" "$root/var/tmp"
|
||||
chmod 1777 "$root/tmp" "$root/var/tmp"
|
||||
install -d -m 0700 -o 999 -g 999 "$root/tmp/agent-cache"
|
||||
|
||||
# Retain package provenance for scanners without shipping apt/dpkg executables.
|
||||
dpkg-query -s "$@" ca-certificates base-files > "$root/var/lib/dpkg/status"
|
||||
mkdir -p "$root/usr/share/doc/ca-certificates"
|
||||
cp /usr/share/doc/ca-certificates/copyright "$root/usr/share/doc/ca-certificates/"
|
||||
ldconfig -r "$root"
|
||||
chroot "$root" /usr/bin/fc-cache --force
|
||||
find "$root" -type f -perm /6000 -exec chmod a-s {} +
|
||||
|
||||
# Execute against the assembled loader/libraries, not the assembly-stage rootfs.
|
||||
chroot --userspec=999:999 "$root" /bin/sh -ec '
|
||||
/home/agent/main -action version
|
||||
ffmpeg -version
|
||||
ffprobe -version
|
||||
test -s /etc/ssl/certs/ca-certificates.crt
|
||||
test ! -e /usr/bin/curl
|
||||
test ! -e /usr/bin/apt
|
||||
test ! -e /usr/bin/dpkg
|
||||
'
|
||||
@@ -3,7 +3,7 @@ services:
|
||||
kerberos-agent1:
|
||||
image: "kerberos/agent:latest"
|
||||
ports:
|
||||
- "8081:80"
|
||||
- "8081:8080"
|
||||
environment:
|
||||
- AGENT_NAME=agent1
|
||||
# You can still override the configuration with environment variables, but might not makes sense if you are attaching a host config.
|
||||
@@ -14,14 +14,14 @@ services:
|
||||
kerberos-agent2:
|
||||
image: "kerberos/agent:latest"
|
||||
ports:
|
||||
- "8082:80"
|
||||
- "8082:8080"
|
||||
volumes:
|
||||
- ./agent2/config:/home/agent/data/config
|
||||
- ./agent2/recordings:/home/agent/data/recordings
|
||||
kerberos-agent3:
|
||||
image: "kerberos/agent:latest"
|
||||
ports:
|
||||
- "8083:80"
|
||||
- "8083:8080"
|
||||
volumes:
|
||||
- ./agent3/config:/home/agent/data/config
|
||||
- ./agent3/recordings:/home/agent/data/recordings
|
||||
@@ -8,7 +8,7 @@ services:
|
||||
kerberos-agent1:
|
||||
image: "kerberos/agent:latest"
|
||||
ports:
|
||||
- "8081:80"
|
||||
- "8081:8080"
|
||||
environment:
|
||||
<<: *common-variables
|
||||
AGENT_NAME: agent1
|
||||
@@ -17,7 +17,7 @@ services:
|
||||
kerberos-agent2:
|
||||
image: "kerberos/agent:latest"
|
||||
ports:
|
||||
- "8082:80"
|
||||
- "8082:8080"
|
||||
environment:
|
||||
<<: *common-variables
|
||||
AGENT_NAME: agent2
|
||||
@@ -26,7 +26,7 @@ services:
|
||||
kerberos-agent3:
|
||||
image: "kerberos/agent:latest"
|
||||
ports:
|
||||
- "8083:80"
|
||||
- "8083:8080"
|
||||
environment:
|
||||
<<: *common-variables
|
||||
AGENT_NAME: agent3
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
image=${1:?Usage: sh deployments/docker/test-image.sh IMAGE}
|
||||
container=
|
||||
volume=
|
||||
temporary_volume=
|
||||
cleanup() {
|
||||
if [ -n "$container" ]; then docker rm -f "$container" >/dev/null; fi
|
||||
if [ -n "$volume" ]; then docker volume rm "$volume" >/dev/null; fi
|
||||
if [ -n "$temporary_volume" ]; then docker volume rm "$temporary_volume" >/dev/null; fi
|
||||
}
|
||||
trap cleanup EXIT
|
||||
trap 'exit 1' HUP INT TERM
|
||||
|
||||
docker run --rm --entrypoint /bin/sh "$image" -ec '
|
||||
test "$(id -u)" = 999
|
||||
test "$(id -g)" = 999
|
||||
test ! -w /home/agent
|
||||
test ! -w /home/agent/main
|
||||
test -w /home/agent/data/config
|
||||
test -w /home/agent/data/recordings
|
||||
test -w /home/agent/data/tus
|
||||
test ! -w /home/agent/www
|
||||
test ! -w /home/agent/www/env.js
|
||||
test -z "$(find / -xdev -type f -perm /6000 -print 2>/dev/null)"
|
||||
! command -v setcap
|
||||
! command -v capsh
|
||||
! command -v apt
|
||||
! command -v apt-get
|
||||
! command -v dpkg
|
||||
! command -v curl
|
||||
test -s /var/lib/dpkg/status
|
||||
test -r /etc/os-release
|
||||
test -r /usr/share/terminfo/x/xterm-256color
|
||||
test -s /etc/ssl/certs/ca-certificates.crt
|
||||
test "$(id -Gn)" = "kerberosio"
|
||||
test "$(stat -c %a /tmp)" = 1777
|
||||
test -w "$XDG_CACHE_HOME"
|
||||
test ! -e /home/agent/.env
|
||||
test -z "$(find /home/agent/data/tus -type f -print)"
|
||||
./main -action version
|
||||
ffmpeg -nostdin -v error -f lavfi -i sine=frequency=1000:sample_rate=8000 \
|
||||
-t 0.1 -c:a aac -f adts /tmp/test.aac
|
||||
ffmpeg -nostdin -v error -i /tmp/test.aac -ar 8000 -ac 1 \
|
||||
-c:a pcm_mulaw -f mulaw /tmp/test.pcm
|
||||
test -s /tmp/test.pcm
|
||||
ffprobe -v error -show_entries stream=codec_name data/test-480p.mp4
|
||||
ffmpeg -nostdin -v error -i data/test-480p.mp4 -frames:v 1 -f null -
|
||||
ffmpeg -nostdin -v error -i data/test-480p.mp4 -frames:v 1 \
|
||||
-c:v libx265 -x265-params pools=none:frame-threads=1:log-level=error \
|
||||
-f hevc /tmp/test.hevc
|
||||
ffmpeg -nostdin -v error -i /tmp/test.hevc -frames:v 1 -f null -
|
||||
ffmpeg -nostdin -v error -f lavfi -i color=black:s=64x64 \
|
||||
-vf drawtext=text=scratch:fontcolor=white -frames:v 1 -f null -
|
||||
'
|
||||
|
||||
# Exercise the same shell and PTY devices used by remote-access sessions.
|
||||
docker run --rm -t --entrypoint /bin/sh "$image" -ec '
|
||||
test -t 0
|
||||
test -t 1
|
||||
test -c /dev/ptmx
|
||||
test -d /dev/pts
|
||||
stty size
|
||||
printf "Shell and PTY ready\n"
|
||||
'
|
||||
docker run --rm --group-add 44 --entrypoint /bin/sh "$image" -ec '
|
||||
test "$(id -Gn)" = "kerberosio video"
|
||||
'
|
||||
wait_healthy() {
|
||||
attempt=0
|
||||
while [ "$attempt" -lt 60 ]; do
|
||||
status=$(docker inspect --format '{{.State.Health.Status}}' "$container")
|
||||
if [ "$status" = healthy ]; then return; fi
|
||||
if [ "$(docker inspect --format '{{.State.Running}}' "$container")" != true ]; then
|
||||
break
|
||||
fi
|
||||
attempt=$((attempt + 1))
|
||||
sleep 1
|
||||
done
|
||||
docker logs "$container"
|
||||
docker inspect --format '{{json .State.Health}}' "$container"
|
||||
echo "Agent did not become healthy" >&2
|
||||
return 1
|
||||
}
|
||||
|
||||
# Exercise the unprivileged default port without any capabilities.
|
||||
volume=$(docker volume create)
|
||||
container=$(docker run -d --cap-drop ALL --security-opt no-new-privileges=true \
|
||||
--sysctl net.ipv4.ip_unprivileged_port_start=1024 \
|
||||
--health-interval=1s --health-start-period=0s \
|
||||
--mount "type=volume,source=$volume,target=/home/agent/data" "$image")
|
||||
wait_healthy
|
||||
docker exec "$container" sh -ec '
|
||||
test "$AGENT_PORT" = 8080
|
||||
./main -action healthcheck
|
||||
test -r data/config/config.json
|
||||
touch data/config/.permission-test data/recordings/.permission-test data/tus/.permission-test
|
||||
rm data/config/.permission-test data/recordings/.permission-test data/tus/.permission-test
|
||||
'
|
||||
if docker exec -e AGENT_PORT=65534 "$container" ./main -action healthcheck; then
|
||||
echo "Healthcheck incorrectly succeeded on a port with no Agent" >&2
|
||||
exit 1
|
||||
fi
|
||||
docker stop --time 10 "$container" >/dev/null
|
||||
docker rm "$container" >/dev/null
|
||||
container=
|
||||
|
||||
# Demo UI selection must work with immutable assets and a read-only root.
|
||||
temporary_volume=$(docker volume create)
|
||||
container=$(docker run -d --read-only --cap-drop ALL \
|
||||
--security-opt no-new-privileges=true \
|
||||
--sysctl net.ipv4.ip_unprivileged_port_start=1024 \
|
||||
--health-interval=1s --health-start-period=0s \
|
||||
--mount "type=volume,source=$volume,target=/home/agent/data" \
|
||||
--mount "type=volume,source=$temporary_volume,target=/tmp" \
|
||||
-e AGENT_PORT=8082 -e AGENT_MODE=demo \
|
||||
-e http_proxy=http://127.0.0.1:9 -e HTTP_PROXY=http://127.0.0.1:9 \
|
||||
-e no_proxy= -e NO_PROXY= "$image")
|
||||
wait_healthy
|
||||
docker exec "$container" sh -ec '
|
||||
test -f www/env.js
|
||||
test -f www/env.demo.js
|
||||
test ! -w www
|
||||
ffmpeg -nostdin -v error -f lavfi -i color=black:s=64x64 \
|
||||
-vf drawtext=text=readonly:fontcolor=white -frames:v 1 -f null -
|
||||
'
|
||||
echo "Scratch image permissions, media, shell/PTY, volume writes, default/custom ports, and demo startup passed."
|
||||
@@ -6,6 +6,27 @@ Kubernetes can help you to build a scalable, flexible and resilient deployment.
|
||||
|
||||
We've provided an example deployment `deployment-agent.yml` in this directory, which show case you have to create a deployment (and under the hood a pod), to run a Kerberos Agent workload.
|
||||
|
||||
These manifests target the forthcoming hardened image: **containerPort and
|
||||
Service targetPort are 8080**, while external Service/Ingress port 80 stays
|
||||
unchanged. Pin a published hardened release digest before production use.
|
||||
Previously published port-80 images (including `v3.14.1`) require the old
|
||||
container/target ports; upgrade the image and mapping together. Host-network
|
||||
deployments use host port 8080 without Service port translation.
|
||||
|
||||
The examples use UID/GID `999:999`, `fsGroup: 999`, a read-only root filesystem,
|
||||
no privilege escalation, all capabilities dropped and runtime-default seccomp.
|
||||
A non-root init container copies missing packaged data to the writable volume
|
||||
without overwriting existing files and initializes the user cache. Temporary
|
||||
storage is ephemeral. The PVC example preserves the existing `config/`,
|
||||
`recordings/`, `snapshots/` and `cloud/` directories under the same PVC root,
|
||||
mounting that root at `/home/agent/data` to cover all writable data paths.
|
||||
Ensure the storage driver honors fsGroup or pre-provision UID/GID permissions.
|
||||
If deliberately passing video devices, add their actual GID with
|
||||
`supplementalGroups`; ordinary IP cameras do not need that group or devices.
|
||||
See the [image contract](../docker/README.md#image-contract), including the pending
|
||||
remote-terminal policy exception and release blockers. These examples do not
|
||||
assert a running cluster or security-policy approval.
|
||||
|
||||
## Create a Kerberos Agent deployment
|
||||
|
||||
It's always a best practices to isolate and structure your workloads in Kubernetes. To achieve this we are utilising the concept of namespaces. For this example we will create a new namespace `demo`.
|
||||
@@ -61,8 +82,7 @@ Depending on where and how you are hosting the Kubernetes cluster, you may need
|
||||
image: kerberos/agent:latest
|
||||
volumeMounts:
|
||||
- name: kerberos-data
|
||||
mountPath: /home/agent/data/config
|
||||
subPath: config
|
||||
mountPath: /home/agent/data
|
||||
...
|
||||
|
||||
## Expose with Ingress
|
||||
@@ -76,6 +96,7 @@ In the first example `deployment-agent.yml` we are using a `LoadBalancer` to exp
|
||||
type: LoadBalancer
|
||||
ports:
|
||||
- port: 80
|
||||
targetPort: 8080
|
||||
...
|
||||
|
||||
An alternative to `LoadBalancer` is `Ingress`. By leveraging an ingress such as `ingress-nginx` or `traefik` you setup a gateway (single point of contact), through which all communication to your apps (services) will flow.
|
||||
|
||||
@@ -14,41 +14,56 @@ spec:
|
||||
labels:
|
||||
app: agent
|
||||
spec:
|
||||
securityContext:
|
||||
runAsNonRoot: true
|
||||
runAsUser: 999
|
||||
runAsGroup: 999
|
||||
fsGroup: 999
|
||||
seccompProfile:
|
||||
type: RuntimeDefault
|
||||
volumes:
|
||||
- name: kerberos-data
|
||||
persistentVolumeClaim:
|
||||
claimName: kerberos-data
|
||||
- name: temporary
|
||||
emptyDir: {}
|
||||
|
||||
initContainers:
|
||||
- name: download-config
|
||||
image: kerberos/agent:latest
|
||||
securityContext:
|
||||
allowPrivilegeEscalation: false
|
||||
readOnlyRootFilesystem: true
|
||||
capabilities:
|
||||
drop: ["ALL"]
|
||||
volumeMounts:
|
||||
- name: kerberos-data
|
||||
mountPath: /home/agent/data/config
|
||||
subPath: config
|
||||
command:
|
||||
[
|
||||
"cp",
|
||||
"/home/agent/data/config.template.json",
|
||||
"/home/agent/data/config/config.json",
|
||||
]
|
||||
mountPath: /runtime-data
|
||||
- name: temporary
|
||||
mountPath: /runtime-tmp
|
||||
command: ["/bin/sh", "-ec", "cp -R --update=none /home/agent/data/. /runtime-data/; install -d -m 0700 /runtime-tmp/agent-cache"]
|
||||
|
||||
containers:
|
||||
- name: agent
|
||||
image: kerberos/agent:latest
|
||||
livenessProbe:
|
||||
exec:
|
||||
command: ["/home/agent/main", "-action", "healthcheck"]
|
||||
initialDelaySeconds: 10
|
||||
periodSeconds: 10
|
||||
timeoutSeconds: 10
|
||||
securityContext:
|
||||
allowPrivilegeEscalation: false
|
||||
readOnlyRootFilesystem: true
|
||||
capabilities:
|
||||
drop: ["ALL"]
|
||||
volumeMounts:
|
||||
- name: kerberos-data
|
||||
mountPath: /home/agent/data/config
|
||||
subPath: config
|
||||
- name: kerberos-data
|
||||
mountPath: /home/agent/data/recordings
|
||||
subPath: recordings
|
||||
- name: kerberos-data
|
||||
mountPath: /home/agent/data/snapshots
|
||||
subPath: snapshots
|
||||
- name: kerberos-data
|
||||
mountPath: /home/agent/data/cloud
|
||||
subPath: cloud
|
||||
mountPath: /home/agent/data
|
||||
- name: temporary
|
||||
mountPath: /tmp
|
||||
- name: temporary
|
||||
mountPath: /var/tmp
|
||||
ports:
|
||||
- containerPort: 80
|
||||
- containerPort: 8080
|
||||
protocol: TCP
|
||||
@@ -14,11 +14,55 @@ spec:
|
||||
labels:
|
||||
app: agent
|
||||
spec:
|
||||
securityContext:
|
||||
runAsNonRoot: true
|
||||
runAsUser: 999
|
||||
runAsGroup: 999
|
||||
fsGroup: 999
|
||||
seccompProfile:
|
||||
type: RuntimeDefault
|
||||
volumes:
|
||||
- name: data
|
||||
emptyDir: {}
|
||||
- name: temporary
|
||||
emptyDir: {}
|
||||
initContainers:
|
||||
- name: initialize-data
|
||||
image: kerberos/agent:latest
|
||||
command: ["/bin/sh", "-ec", "cp -R --update=none /home/agent/data/. /runtime-data/; install -d -m 0700 /runtime-tmp/agent-cache"]
|
||||
securityContext:
|
||||
allowPrivilegeEscalation: false
|
||||
readOnlyRootFilesystem: true
|
||||
capabilities:
|
||||
drop: ["ALL"]
|
||||
volumeMounts:
|
||||
- name: data
|
||||
mountPath: /runtime-data
|
||||
- name: temporary
|
||||
mountPath: /runtime-tmp
|
||||
containers:
|
||||
- name: agent
|
||||
image: kerberos/agent:latest
|
||||
livenessProbe:
|
||||
exec:
|
||||
command: ["/home/agent/main", "-action", "healthcheck"]
|
||||
initialDelaySeconds: 10
|
||||
periodSeconds: 10
|
||||
timeoutSeconds: 10
|
||||
securityContext:
|
||||
allowPrivilegeEscalation: false
|
||||
readOnlyRootFilesystem: true
|
||||
capabilities:
|
||||
drop: ["ALL"]
|
||||
volumeMounts:
|
||||
- name: data
|
||||
mountPath: /home/agent/data
|
||||
- name: temporary
|
||||
mountPath: /tmp
|
||||
- name: temporary
|
||||
mountPath: /var/tmp
|
||||
ports:
|
||||
- containerPort: 80
|
||||
- containerPort: 8080
|
||||
protocol: TCP
|
||||
resources:
|
||||
limits:
|
||||
@@ -48,7 +92,7 @@ spec:
|
||||
#type: LoadBalancer
|
||||
ports:
|
||||
- port: 80
|
||||
targetPort: 80
|
||||
targetPort: 8080
|
||||
selector:
|
||||
app: agent
|
||||
---
|
||||
|
||||
@@ -14,11 +14,55 @@ spec:
|
||||
labels:
|
||||
app: agent
|
||||
spec:
|
||||
securityContext:
|
||||
runAsNonRoot: true
|
||||
runAsUser: 999
|
||||
runAsGroup: 999
|
||||
fsGroup: 999
|
||||
seccompProfile:
|
||||
type: RuntimeDefault
|
||||
volumes:
|
||||
- name: data
|
||||
emptyDir: {}
|
||||
- name: temporary
|
||||
emptyDir: {}
|
||||
initContainers:
|
||||
- name: initialize-data
|
||||
image: kerberos/agent:latest
|
||||
command: ["/bin/sh", "-ec", "cp -R --update=none /home/agent/data/. /runtime-data/; install -d -m 0700 /runtime-tmp/agent-cache"]
|
||||
securityContext:
|
||||
allowPrivilegeEscalation: false
|
||||
readOnlyRootFilesystem: true
|
||||
capabilities:
|
||||
drop: ["ALL"]
|
||||
volumeMounts:
|
||||
- name: data
|
||||
mountPath: /runtime-data
|
||||
- name: temporary
|
||||
mountPath: /runtime-tmp
|
||||
containers:
|
||||
- name: agent
|
||||
image: kerberos/agent:3.2.3
|
||||
image: kerberos/agent:latest
|
||||
livenessProbe:
|
||||
exec:
|
||||
command: ["/home/agent/main", "-action", "healthcheck"]
|
||||
initialDelaySeconds: 10
|
||||
periodSeconds: 10
|
||||
timeoutSeconds: 10
|
||||
securityContext:
|
||||
allowPrivilegeEscalation: false
|
||||
readOnlyRootFilesystem: true
|
||||
capabilities:
|
||||
drop: ["ALL"]
|
||||
volumeMounts:
|
||||
- name: data
|
||||
mountPath: /home/agent/data
|
||||
- name: temporary
|
||||
mountPath: /tmp
|
||||
- name: temporary
|
||||
mountPath: /var/tmp
|
||||
ports:
|
||||
- containerPort: 80
|
||||
- containerPort: 8080
|
||||
protocol: TCP
|
||||
resources:
|
||||
limits:
|
||||
@@ -48,6 +92,6 @@ spec:
|
||||
type: LoadBalancer
|
||||
ports:
|
||||
- port: 80
|
||||
targetPort: 80
|
||||
targetPort: 8080
|
||||
selector:
|
||||
app: agent
|
||||
|
||||
@@ -4,6 +4,13 @@ If you are using Terraform as part of your DevOps stack, you might utilise it to
|
||||
|
||||
For this example we will install Kerberos Agent using `docker` on a remote `linux` machine. Therefore we'll make sure we have the `TelkomIndonesia/linux` provider initialised.
|
||||
|
||||
The example targets the forthcoming hardened image and maps the configured host
|
||||
port (80 by default) to **container port 8080**. Pin a published hardened release
|
||||
digest before deployment. Older releases, including `v3.14.1`, still require
|
||||
container port 80; change the image and mapping together. See the
|
||||
[image contract](../docker/README.md#image-contract) for runtime permissions,
|
||||
writable paths and release-policy limitations.
|
||||
|
||||
terraform init
|
||||
|
||||
Once initialised you should see similar output:
|
||||
|
||||
@@ -34,9 +34,9 @@ resource "linux_script" "install_docker" {
|
||||
|
||||
resource "linux_script" "install_docker_kerberos_agent" {
|
||||
lifecycle_commands {
|
||||
create = "docker pull $IMAGE:$VERSION && docker run -d -p $PORT:80 --name agent $IMAGE:$VERSION"
|
||||
create = "docker pull $IMAGE:$VERSION && docker run -d -p $PORT:8080 --name agent $IMAGE:$VERSION"
|
||||
read = "docker inspect agent"
|
||||
update = "docker pull $IMAGE:$VERSION && docker rm agent --force && docker run -d -p $PORT:80 --name agent $IMAGE:$VERSION"
|
||||
update = "docker pull $IMAGE:$VERSION && docker rm agent --force && docker run -d -p $PORT:8080 --name agent $IMAGE:$VERSION"
|
||||
delete = "docker rm agent --force"
|
||||
}
|
||||
environment = {
|
||||
|
||||
@@ -26,28 +26,3 @@ Kerberos Open source (v3) is a cutting edge video surveillance management system
|
||||
## Security reporting
|
||||
|
||||
For sensitive vulnerabilities, use private disclosure channels documented in [../SECURITY.md](../SECURITY.md).
|
||||
|
||||
## WebRTC startup and keyframe recovery
|
||||
|
||||
Each H264 viewer waits until its WebRTC transport is connected and a fresh IDR
|
||||
arrives before receiving video. Reconnects, viewer PLI/FIR feedback, and a full
|
||||
per-viewer sample buffer reset that viewer's keyframe gate without stalling
|
||||
other viewers. Audio continues to use the existing independent sample queues.
|
||||
Each viewer's skipped and discarded video durations advance its RTP clock before
|
||||
recovery, without sending filler packets, so an IDR wait does not compress the
|
||||
video timeline relative to audio.
|
||||
|
||||
The main and sub streams request keyframes from their own RTSP sources. Viewer
|
||||
PLI and FIR feedback is translated into an RTSP PLI using the camera session's
|
||||
SSRCs, never forwarded with the browser's SSRCs. Requests are coalesced and
|
||||
limited to one per second per broadcaster, retrying while connected viewers
|
||||
still need an IDR. Requests stop once all waiting viewers receive an IDR or
|
||||
the broadcaster closes.
|
||||
|
||||
Camera support for RTCP PLI varies. Unsupported sources, cameras that ignore
|
||||
feedback, and failed requests fall back to the next periodic IDR; failures are
|
||||
logged as `keyframe_request_failed`. No encoder settings are changed. A camera
|
||||
with a long GOP can therefore still start slowly; configure a shorter IDR
|
||||
interval (for example 1-2 seconds) when camera feedback is unavailable, accounting
|
||||
for the bandwidth tradeoff. An isolated cached IDR must not be replayed followed
|
||||
by arbitrary live P-frames: the dependent reference chain would be incomplete.
|
||||
|
||||
+28
-27
@@ -1,6 +1,6 @@
|
||||
module github.com/kerberos-io/agent/machinery
|
||||
|
||||
go 1.25.0
|
||||
go 1.26.10
|
||||
|
||||
replace google.golang.org/genproto => google.golang.org/genproto v0.0.0-20250519155744-55703ea1f237
|
||||
|
||||
@@ -14,7 +14,7 @@ require (
|
||||
github.com/creack/pty v1.1.24
|
||||
github.com/dromara/carbon/v2 v2.6.8
|
||||
github.com/dropbox/dropbox-sdk-go-unofficial/v6 v6.0.5
|
||||
github.com/eclipse/paho.mqtt.golang v1.5.0
|
||||
github.com/eclipse/paho.mqtt.golang v1.5.1
|
||||
github.com/elastic/go-sysinfo v1.15.3
|
||||
github.com/gin-contrib/cors v1.7.5
|
||||
github.com/gin-contrib/pprof v1.5.3
|
||||
@@ -30,7 +30,6 @@ require (
|
||||
github.com/moq-dev/moq-go v0.5.7
|
||||
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
|
||||
github.com/pion/interceptor v0.1.47
|
||||
github.com/pion/rtcp v1.2.17
|
||||
github.com/pion/rtp v1.10.5
|
||||
github.com/pion/webrtc/v4 v4.2.18
|
||||
github.com/sirupsen/logrus v1.9.3
|
||||
@@ -40,12 +39,13 @@ require (
|
||||
github.com/swaggo/swag v1.16.4
|
||||
github.com/tevino/abool v1.2.0
|
||||
github.com/zaf/g711 v1.4.0
|
||||
go.mongodb.org/mongo-driver v1.17.3
|
||||
go.opentelemetry.io/otel v1.36.0
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.36.0
|
||||
go.opentelemetry.io/otel/sdk v1.36.0
|
||||
go.opentelemetry.io/otel/trace v1.36.0
|
||||
go.mongodb.org/mongo-driver v1.17.7
|
||||
go.opentelemetry.io/otel v1.45.0
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.45.0
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.45.0
|
||||
go.opentelemetry.io/otel/sdk v1.45.0
|
||||
go.opentelemetry.io/otel/trace v1.45.0
|
||||
golang.org/x/net v0.62.0
|
||||
)
|
||||
|
||||
require (
|
||||
@@ -56,7 +56,8 @@ require (
|
||||
github.com/bluenviron/mediacommon/v2 v2.9.2 // indirect
|
||||
github.com/bytedance/sonic v1.13.2 // indirect
|
||||
github.com/bytedance/sonic/loader v0.2.4 // indirect
|
||||
github.com/cenkalti/backoff/v5 v5.0.2 // indirect
|
||||
github.com/cenkalti/backoff/v5 v5.0.3 // indirect
|
||||
github.com/cespare/xxhash/v2 v2.3.0 // indirect
|
||||
github.com/clbanning/mxj v1.8.4 // indirect
|
||||
github.com/clbanning/mxj/v2 v2.7.0 // indirect
|
||||
github.com/cloudwego/base64x v0.1.5 // indirect
|
||||
@@ -66,7 +67,7 @@ require (
|
||||
github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5 // indirect
|
||||
github.com/gabriel-vasile/mimetype v1.4.8 // indirect
|
||||
github.com/gin-contrib/sse v1.0.0 // indirect
|
||||
github.com/go-logr/logr v1.4.2 // indirect
|
||||
github.com/go-logr/logr v1.4.4 // indirect
|
||||
github.com/go-logr/stdr v1.2.2 // indirect
|
||||
github.com/go-openapi/jsonpointer v0.19.5 // indirect
|
||||
github.com/go-openapi/jsonreference v0.19.6 // indirect
|
||||
@@ -78,11 +79,11 @@ require (
|
||||
github.com/goccy/go-json v0.10.5 // indirect
|
||||
github.com/golang/snappy v0.0.4 // indirect
|
||||
github.com/google/uuid v1.6.0 // indirect
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 // indirect
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect
|
||||
github.com/josharian/intern v1.0.0 // indirect
|
||||
github.com/json-iterator/go v1.1.12 // indirect
|
||||
github.com/juju/errors v1.0.0 // indirect
|
||||
github.com/klauspost/compress v1.16.7 // indirect
|
||||
github.com/klauspost/compress v1.18.7 // indirect
|
||||
github.com/klauspost/cpuid v1.2.3 // indirect
|
||||
github.com/klauspost/cpuid/v2 v2.2.10 // indirect
|
||||
github.com/kylelemons/go-gypsy v1.0.0 // indirect
|
||||
@@ -105,6 +106,7 @@ require (
|
||||
github.com/pion/logging v0.2.4 // indirect
|
||||
github.com/pion/mdns/v2 v2.1.0 // indirect
|
||||
github.com/pion/randutil v0.1.0 // indirect
|
||||
github.com/pion/rtcp v1.2.17 // indirect
|
||||
github.com/pion/sctp v1.11.1 // indirect
|
||||
github.com/pion/sdp/v3 v3.0.19 // indirect
|
||||
github.com/pion/srtp/v3 v3.0.12 // indirect
|
||||
@@ -121,22 +123,21 @@ require (
|
||||
github.com/xdg-go/stringprep v1.0.4 // indirect
|
||||
github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
|
||||
github.com/ziutek/mymysql v1.5.4 // indirect
|
||||
go.opentelemetry.io/auto/sdk v1.1.0 // indirect
|
||||
go.opentelemetry.io/otel/metric v1.36.0 // indirect
|
||||
go.opentelemetry.io/proto/otlp v1.6.0 // indirect
|
||||
go.opentelemetry.io/auto/sdk v1.2.1 // indirect
|
||||
go.opentelemetry.io/otel/metric v1.45.0 // indirect
|
||||
go.opentelemetry.io/proto/otlp v1.11.0 // indirect
|
||||
golang.org/x/arch v0.16.0 // indirect
|
||||
golang.org/x/crypto v0.54.0 // indirect
|
||||
golang.org/x/net v0.57.0 // indirect
|
||||
golang.org/x/oauth2 v0.30.0 // indirect
|
||||
golang.org/x/sync v0.22.0 // indirect
|
||||
golang.org/x/sys v0.47.0 // indirect
|
||||
golang.org/x/text v0.40.0 // indirect
|
||||
golang.org/x/crypto v0.58.1-0.20261009181718-2f1f834330b2 // indirect
|
||||
golang.org/x/oauth2 v0.36.0 // indirect
|
||||
golang.org/x/sync v0.24.0 // indirect
|
||||
golang.org/x/sys v0.49.0 // indirect
|
||||
golang.org/x/text v0.43.0 // indirect
|
||||
golang.org/x/time v0.14.0 // indirect
|
||||
golang.org/x/tools v0.47.0 // indirect
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20250519155744-55703ea1f237 // indirect
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20250519155744-55703ea1f237 // indirect
|
||||
google.golang.org/grpc v1.72.1 // indirect
|
||||
google.golang.org/protobuf v1.36.6 // indirect
|
||||
golang.org/x/tools v0.51.0 // indirect
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20260803160001-6ac0973c030d // indirect
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20260803160001-6ac0973c030d // indirect
|
||||
google.golang.org/grpc v1.83.2 // indirect
|
||||
google.golang.org/protobuf v1.36.11 // indirect
|
||||
gopkg.in/ini.v1 v1.42.0 // indirect
|
||||
gopkg.in/yaml.v2 v2.4.0 // indirect
|
||||
gopkg.in/yaml.v3 v3.0.1 // indirect
|
||||
|
||||
+76
-35
@@ -410,12 +410,15 @@ github.com/cedricve/go-onvif v0.0.0-20200222191200-567e8ce298f6 h1:bzFZYgZD5vf4P
|
||||
github.com/cedricve/go-onvif v0.0.0-20200222191200-567e8ce298f6/go.mod h1:nBrjN2nMHendp0Cvb/6GaJ1v92Qv/kzqxWtNBnKJEK0=
|
||||
github.com/cenkalti/backoff/v5 v5.0.2 h1:rIfFVxEf1QsI7E1ZHfp/B4DF/6QBAUhmgkxc0H7Zss8=
|
||||
github.com/cenkalti/backoff/v5 v5.0.2/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
|
||||
github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
|
||||
github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
|
||||
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
|
||||
github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
|
||||
github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw=
|
||||
github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
|
||||
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||
github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
|
||||
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||
github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
|
||||
github.com/chzyer/logex v1.2.0/go.mod h1:9+9sk7u7pGNWYMkh0hdiL++6OeibzJccyQU4p4MedaY=
|
||||
@@ -470,6 +473,8 @@ github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25Kn
|
||||
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
|
||||
github.com/eclipse/paho.mqtt.golang v1.5.0 h1:EH+bUVJNgttidWFkLLVKaQPGmkTUfQQqjOsyvMGvD6o=
|
||||
github.com/eclipse/paho.mqtt.golang v1.5.0/go.mod h1:du/2qNQVqJf/Sqs4MEL77kR8QTqANF7XU7Fk0aOTAgk=
|
||||
github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE=
|
||||
github.com/eclipse/paho.mqtt.golang v1.5.1/go.mod h1:1/yJCneuyOoCOzKSsOTUc0AJfpsItBGWvYpBLimhArU=
|
||||
github.com/elastic/go-sysinfo v1.15.3 h1:W+RnmhKFkqPTCRoFq2VCTmsT4p/fwpo+3gKNQsn1XU0=
|
||||
github.com/elastic/go-sysinfo v1.15.3/go.mod h1:K/cNrqYTDrSoMh2oDkYEMS2+a72GRxMvNP+GC+vRIlo=
|
||||
github.com/elastic/go-windows v1.0.2 h1:yoLLsAsV5cfg9FLhZ9EXZ2n2sQFKeDYrHenkcivY4vI=
|
||||
@@ -548,8 +553,11 @@ github.com/go-latex/latex v0.0.0-20210823091927-c0d11ff05a81/go.mod h1:SX0U8uGpx
|
||||
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
|
||||
github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
|
||||
github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
|
||||
github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
|
||||
github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
|
||||
github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
|
||||
github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
|
||||
github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8=
|
||||
github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
|
||||
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
|
||||
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
|
||||
github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
|
||||
@@ -748,6 +756,8 @@ github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0/go.mod h1:YN5jB8ie0yfIUg6VvR9Kz84aCaG7AsGZnLjhHbUqwPg=
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 h1:5ZPtiqj0JL5oKWmcsq4VMaAW5ukBEgSGXEN89zeH1Jo=
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3/go.mod h1:ndYquD05frm2vACXE1nsccT4oJzjhw2arTS2cpUD1PI=
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 h1:5VipnvEpbqr2gA2VbM+nYVbkIF28c5ZQfqCBQ5g2xfk=
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0/go.mod h1:Hyl3n6Twe1hvtd9XUXDec4pTvgMSEixRuQKPTMH2bNs=
|
||||
github.com/hamba/avro/v2 v2.17.2/go.mod h1:Q9YK+qxAhtVrNqOhwlZTATLgLA8qxG2vtvkhK8fJ7Jo=
|
||||
github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
|
||||
github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
|
||||
@@ -781,8 +791,9 @@ github.com/kerberos-io/onvif v1.2.3/go.mod h1:XSgEQXmEDjUQTbdXvsaRJt6Az8YPGj7L+j
|
||||
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
|
||||
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
|
||||
github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE=
|
||||
github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
|
||||
github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
|
||||
github.com/klauspost/compress v1.18.7 h1:aUyZsS4kH3QTKurYhAOwAHxllVPnOthb3vPfnF1Ehjw=
|
||||
github.com/klauspost/compress v1.18.7/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
|
||||
github.com/klauspost/cpuid v1.2.3 h1:CCtW0xUnWGVINKvE/WWOYKdsPV6mawAtvQuSl8guwQs=
|
||||
github.com/klauspost/cpuid v1.2.3/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
|
||||
github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
|
||||
@@ -924,8 +935,9 @@ github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFR
|
||||
github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
|
||||
github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
|
||||
github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
|
||||
github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
|
||||
github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
|
||||
github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
|
||||
github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
|
||||
github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w=
|
||||
github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245/go.mod h1:pQAZKsJ8yyVxGRWYNEm9oFB8ieLgKFnamEyDmSA0BRk=
|
||||
github.com/sirupsen/logrus v1.5.0/go.mod h1:+F7Ogzej0PZc/94MaYx/nvG9jOFMD2osvC3s+Squfpo=
|
||||
@@ -1011,6 +1023,8 @@ go.einride.tech/aip v0.67.1/go.mod h1:ZGX4/zKw8dcgzdLsrvpOOGxfxI2QSk12SlP7d6c0/X
|
||||
go.einride.tech/aip v0.68.1/go.mod h1:XaFtaj4HuA3Zwk9xoBtTWgNubZ0ZZXv9BZJCkuKuWbg=
|
||||
go.mongodb.org/mongo-driver v1.17.3 h1:TQyXhnsWfWtgAhMtOgtYHMTkZIfBTpMTsMnd9ZBeHxQ=
|
||||
go.mongodb.org/mongo-driver v1.17.3/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
|
||||
go.mongodb.org/mongo-driver v1.17.7 h1:a9w+U3Vt67eYzcfq3k/OAv284/uUUkL0uP75VE5rCOU=
|
||||
go.mongodb.org/mongo-driver v1.17.7/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
|
||||
go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
|
||||
go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
|
||||
go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
|
||||
@@ -1019,8 +1033,9 @@ go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
|
||||
go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
|
||||
go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
|
||||
go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
|
||||
go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
|
||||
go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
|
||||
go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
|
||||
go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
|
||||
go.opentelemetry.io/contrib/detectors/gcp v1.28.0/go.mod h1:9BIqH22qyHWAiZxQh0whuJygro59z+nbMVuc7ciiGug=
|
||||
go.opentelemetry.io/contrib/detectors/gcp v1.29.0/go.mod h1:GW2aWZNwR2ZxDLdv8OyC2G8zkRoQBuURgV7RPQgcPoU=
|
||||
go.opentelemetry.io/contrib/detectors/gcp v1.31.0/go.mod h1:tzQL6E1l+iV44YFTkcAeNQqzXUiekSYP9jjJjXwEd00=
|
||||
@@ -1059,12 +1074,18 @@ go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGi
|
||||
go.opentelemetry.io/otel v1.33.0/go.mod h1:SUUkR6csvUQl+yjReHu5uM3EtVV7MBm5FHKRlNx4I8I=
|
||||
go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
|
||||
go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y=
|
||||
go.opentelemetry.io/otel v1.36.0 h1:UumtzIklRBY6cI/lllNZlALOF5nNIzJVb16APdvgTXg=
|
||||
go.opentelemetry.io/otel v1.36.0/go.mod h1:/TcFMXYjyRNh8khOAO9ybYkqaDBb/70aVwkNML4pP8E=
|
||||
go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU=
|
||||
go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc=
|
||||
go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU=
|
||||
go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0 h1:dNzwXjZKpMpE2JhmO+9HsPl42NIXFIFSUSSs0fiqra0=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0/go.mod h1:90PoxvaEB5n6AOdZvi+yWJQoE95U8Dhhw2bSyRqnTD0=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.45.0 h1:QRefszxJmfPdjXUUm3j6iDzY03mTPXMjqErFqQ67vUg=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.45.0/go.mod h1:Tiz03lTBVBrm7eWZBOidzEaYaJa8tjwGUGv6d8mlTyk=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.36.0 h1:nRVXXvf78e00EwY6Wp0YII8ww2JVWshZ20HfTlE11AM=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.36.0/go.mod h1:r49hO7CgrxY9Voaj3Xe8pANWtr0Oq916d0XAmOoCZAQ=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.45.0 h1:QBajQ2SrwQijzHyZbQlPsuIzpl/ll8DY6wPWsajeGcI=
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.45.0/go.mod h1:08ZQLjrPLQ6R4kAXvuOvODEer5Yh4CoFvll5qB2BCI8=
|
||||
go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.29.0/go.mod h1:BLbf7zbNIONBLPwvFnwNHGj4zge8uTCM/UPIVW1Mq2I=
|
||||
go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.35.0/go.mod h1:U2R3XyVPzn0WX7wOIypPuptulsMcPDPs/oiSVOMVnHY=
|
||||
go.opentelemetry.io/otel/metric v1.21.0/go.mod h1:o1p3CA8nNHW8j5yuQLdc1eeqEaPfzug24uvsyIEJRWM=
|
||||
@@ -1080,8 +1101,10 @@ go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzau
|
||||
go.opentelemetry.io/otel/metric v1.33.0/go.mod h1:L9+Fyctbp6HFTddIxClbQkjtubW6O9QS3Ann/M82u6M=
|
||||
go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
|
||||
go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE=
|
||||
go.opentelemetry.io/otel/metric v1.36.0 h1:MoWPKVhQvJ+eeXWHFBOPoBOi20jh6Iq2CcCREuTYufE=
|
||||
go.opentelemetry.io/otel/metric v1.36.0/go.mod h1:zC7Ks+yeyJt4xig9DEw9kuUFe5C3zLbVjV2PzT6qzbs=
|
||||
go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc=
|
||||
go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo=
|
||||
go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M=
|
||||
go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s=
|
||||
go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E=
|
||||
go.opentelemetry.io/otel/sdk v1.22.0/go.mod h1:iu7luyVGYovrRpe2fmj3CVKouQNdTOkxtLzPvPz1DOc=
|
||||
go.opentelemetry.io/otel/sdk v1.24.0/go.mod h1:KVrIYw6tEubO9E96HQpcmpTKDVn9gdv35HoYiQWGDFg=
|
||||
@@ -1093,16 +1116,20 @@ go.opentelemetry.io/otel/sdk v1.32.0/go.mod h1:LqgegDBjKMmb2GC6/PrTnteJG39I8/vJC
|
||||
go.opentelemetry.io/otel/sdk v1.33.0/go.mod h1:A1Q5oi7/9XaMlIWzPSxLRWOI8nG3FnzHJNbiENQuihM=
|
||||
go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU=
|
||||
go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg=
|
||||
go.opentelemetry.io/otel/sdk v1.36.0 h1:b6SYIuLRs88ztox4EyrvRti80uXIFy+Sqzoh9kFULbs=
|
||||
go.opentelemetry.io/otel/sdk v1.36.0/go.mod h1:+lC+mTgD+MUWfjJubi2vvXWcVxyr9rmlshZni72pXeY=
|
||||
go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58=
|
||||
go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0=
|
||||
go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw=
|
||||
go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.28.0/go.mod h1:cWPjykihLAPvXKi4iZc1dpER3Jdq2Z0YLse3moQUCpg=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.29.0/go.mod h1:6zZLdCl2fkauYoZIOn/soQIDSWFmNSRcICarHfuhNJQ=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.30.0/go.mod h1:waS6P3YqFNzeP01kuo/MBBYqaoBJl7efRQHOaydhy1Y=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.31.0/go.mod h1:CRInTMVvNhUKgSAMbKyTMxqOBC0zgyxzW55lZzX43Y8=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.32.0/go.mod h1:PWeZlq0zt9YkYAp3gjKZ0eicRYvOh1Gd+X99x6GHpCQ=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA=
|
||||
go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o=
|
||||
go.opentelemetry.io/otel/trace v1.21.0/go.mod h1:LGbsEB0f9LGjN+OZaQQ26sohbOmiMR+BaslueVtS/qQ=
|
||||
go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo=
|
||||
go.opentelemetry.io/otel/trace v1.23.0/go.mod h1:GSGTbIClEsuZrGIzoEHqsVfxgn5UkggkflQwDScNUsk=
|
||||
@@ -1116,14 +1143,18 @@ go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L
|
||||
go.opentelemetry.io/otel/trace v1.33.0/go.mod h1:uIcdVUZMpTAmz0tI1z04GoVSezK37CbGV4fr1f2nBck=
|
||||
go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
|
||||
go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc=
|
||||
go.opentelemetry.io/otel/trace v1.36.0 h1:ahxWNuqZjpdiFAyrIoQ4GIiAIhxAunQR6MUoKrsNd4w=
|
||||
go.opentelemetry.io/otel/trace v1.36.0/go.mod h1:gQ+OnDZzrybY4k4seLzPAWNwVBBVlF2szhehOBB/tGA=
|
||||
go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk=
|
||||
go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE=
|
||||
go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag=
|
||||
go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc=
|
||||
go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
|
||||
go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U=
|
||||
go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U=
|
||||
go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM=
|
||||
go.opentelemetry.io/proto/otlp v1.6.0 h1:jQjP+AQyTf+Fe7OKj/MfkDrmK4MNVtw2NpXsf9fefDI=
|
||||
go.opentelemetry.io/proto/otlp v1.6.0/go.mod h1:cicgGehlFuNdgZkcALOCh3VE6K/u2tAjzlRhDwmVpZc=
|
||||
go.opentelemetry.io/proto/otlp v1.11.0 h1:5rrYs0Ykyj50sdU/JU0x8etU+LubXWb+gED6TbEdMIk=
|
||||
go.opentelemetry.io/proto/otlp v1.11.0/go.mod h1:SmVizdCOAm3XBtG1g1NnOdhW6jtddT72hLMhv8VwA8E=
|
||||
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
|
||||
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
|
||||
golang.org/x/arch v0.16.0 h1:foMtLTdyOmIniqWCHjY6+JxuC54XP1fDwx4N0ASyW+U=
|
||||
@@ -1169,8 +1200,10 @@ golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5
|
||||
golang.org/x/crypto v0.35.0/go.mod h1:dy7dXNW32cAb/6/PRuTNsix8T+vJAqvuIy5Bli/x0YQ=
|
||||
golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
|
||||
golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
|
||||
golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
|
||||
golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
|
||||
golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
|
||||
golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
|
||||
golang.org/x/crypto v0.58.1-0.20261009181718-2f1f834330b2 h1:zGDaB+/Mus2mScKvZ23k+W9NAUbP56sNM9SptgvWI5A=
|
||||
golang.org/x/crypto v0.58.1-0.20261009181718-2f1f834330b2/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
|
||||
golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
|
||||
golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
|
||||
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
|
||||
@@ -1240,8 +1273,8 @@ golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
|
||||
golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
|
||||
golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
|
||||
golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
|
||||
golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
|
||||
golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
|
||||
golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c=
|
||||
golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o=
|
||||
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||
@@ -1329,8 +1362,8 @@ golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
|
||||
golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
|
||||
golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
|
||||
golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
|
||||
golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
|
||||
golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
|
||||
golang.org/x/net v0.62.0 h1:18ELalfM5+XNRwzM2nYqXsZQ9ByS1uhj2O/U7+5jqRY=
|
||||
golang.org/x/net v0.62.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI=
|
||||
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
|
||||
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
|
||||
golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
|
||||
@@ -1380,8 +1413,9 @@ golang.org/x/oauth2 v0.26.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbht
|
||||
golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
|
||||
golang.org/x/oauth2 v0.28.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
|
||||
golang.org/x/oauth2 v0.29.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
|
||||
golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
|
||||
golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
|
||||
golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
|
||||
golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
|
||||
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
@@ -1410,8 +1444,8 @@ golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
|
||||
golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
|
||||
golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
|
||||
golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
|
||||
golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
|
||||
golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
|
||||
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
|
||||
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
||||
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
@@ -1520,8 +1554,8 @@ golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
|
||||
golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
|
||||
golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
|
||||
golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
|
||||
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
|
||||
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
|
||||
golang.org/x/telemetry v0.0.0-20240521205824-bda55230c457/go.mod h1:pRgIJT+bRLFKnoM1ldnzKoxTIn14Yxz928LQRYYgIN0=
|
||||
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
|
||||
@@ -1588,8 +1622,8 @@ golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
|
||||
golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
|
||||
golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
|
||||
golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
|
||||
golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
|
||||
golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
|
||||
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
|
||||
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
|
||||
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
|
||||
golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
|
||||
golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
|
||||
@@ -1677,8 +1711,8 @@ golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxb
|
||||
golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
|
||||
golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI=
|
||||
golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=
|
||||
golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q=
|
||||
golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
|
||||
golang.org/x/tools v0.51.0 h1:k4Xc/1Om9jwkBJBo4NVLMSARBoWtK10mx+W5BnXCeAI=
|
||||
golang.org/x/tools v0.51.0/go.mod h1:9eEncMayCV6zRMGhR5eZEC2iBx98qWcF1HZ9Z7wJOoA=
|
||||
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
@@ -1693,6 +1727,8 @@ gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJ
|
||||
gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0=
|
||||
gonum.org/v1/gonum v0.9.3/go.mod h1:TZumC3NeyVQskjXqmyWt4S3bINhy7B4eYwW69EbyX+0=
|
||||
gonum.org/v1/gonum v0.12.0/go.mod h1:73TDxJfAAHeA8Mk9mf8NlIppyhQNo5GLTcYeqgo2lvY=
|
||||
gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
|
||||
gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
|
||||
gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
|
||||
gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc=
|
||||
gonum.org/v1/plot v0.9.0/go.mod h1:3Pcqqmp6RHvJI72kgb8fThyUnav364FOsdDo2aGW5lY=
|
||||
@@ -1866,8 +1902,10 @@ google.golang.org/genproto/googleapis/api v0.0.0-20250425173222-7b384671a197/go.
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20250428153025-10db94c68c34/go.mod h1:0awUlEkap+Pb1UMeJwJQQAdJQrt3moU7J2moTy69irI=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20250505200425-f936aa4a68b2/go.mod h1:pKLAc5OolXC3ViWGI62vvC0n10CpwAtRcTNCFwTKBEw=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20250512202823-5a2f75b736a9/go.mod h1:W3S/3np0/dPWsWLi1h/UymYctGXaGBM2StwzD0y140U=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20250519155744-55703ea1f237 h1:Kog3KlB4xevJlAcbbbzPfRG0+X9fdoGM+UBRKVz6Wr0=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20250519155744-55703ea1f237/go.mod h1:ezi0AVyMKDWy5xAncvjLWH7UcLBB5n7y2fQ8MzjJcto=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa h1:Kjn0N0tCrDgiAFW+lGO4JZ3ck44CehvJQMAwj9QF0G8=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:q4lMZS6kskjT5HvCPrnnypcDPVJqT/f4nfxmkE7gryY=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20260803160001-6ac0973c030d h1:FarXi840EJWSHYTN3ERkADbPWjl307+FGrA22KAVjjc=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20260803160001-6ac0973c030d/go.mod h1:K/+WGbmBY7aNW1HDw1fJnKYo10i0DkAX6pows00dLig=
|
||||
google.golang.org/genproto/googleapis/bytestream v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:ylj+BE99M198VPbBh6A8d9n3w8fChvyLK3wwBOjXBFA=
|
||||
google.golang.org/genproto/googleapis/bytestream v0.0.0-20231012201019-e917dd12ba7a/go.mod h1:+34luvCflYKiKylNwGJfn9cFBbcL/WrkciMmDmsTQ/A=
|
||||
google.golang.org/genproto/googleapis/bytestream v0.0.0-20231030173426-d783a09b4405/go.mod h1:GRUCuLdzVqZte8+Dl/D4N25yLzcGqqWaYkeVOwulFqw=
|
||||
@@ -1986,8 +2024,10 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197/go.
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20250428153025-10db94c68c34/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20250505200425-f936aa4a68b2/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20250512202823-5a2f75b736a9/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20250519155744-55703ea1f237 h1:cJfm9zPbe1e873mHJzmQ1nwVEeRDU/T1wXDK2kUSU34=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20250519155744-55703ea1f237/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa h1:mZHHdPZl0dbGHCflZgAq/Q468DWVFcU2whhB2KAo8fk=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20260803160001-6ac0973c030d h1:IL4hdHzcUv2l/gcg98/Rj3FbtE6axwqslOW8SW0C+S0=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20260803160001-6ac0973c030d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
|
||||
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
|
||||
google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
|
||||
google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
|
||||
@@ -2062,8 +2102,8 @@ google.golang.org/grpc v1.70.0/go.mod h1:ofIJqVKDXx/JiXrwr2IG4/zwdH9txy3IlF40Rmc
|
||||
google.golang.org/grpc v1.71.0/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec=
|
||||
google.golang.org/grpc v1.71.1/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec=
|
||||
google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM=
|
||||
google.golang.org/grpc v1.72.1 h1:HR03wO6eyZ7lknl75XlxABNVLLFc2PAb6mHlYh756mA=
|
||||
google.golang.org/grpc v1.72.1/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM=
|
||||
google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU=
|
||||
google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8=
|
||||
google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
|
||||
google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0/go.mod h1:Dk1tviKTvMCz5tvh7t+fh94dhmQVHuCt2OzJB3CTW9Y=
|
||||
google.golang.org/grpc/examples v0.0.0-20230224211313-3775f633ce20/go.mod h1:Nr5H8+MlGWr5+xX/STzdoEqJrO+YteqFbMyCsrb6mH0=
|
||||
@@ -2096,8 +2136,9 @@ google.golang.org/protobuf v1.36.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojt
|
||||
google.golang.org/protobuf v1.36.3/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
|
||||
google.golang.org/protobuf v1.36.4/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
|
||||
google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
|
||||
google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
|
||||
google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
|
||||
google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
|
||||
google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
func checkAgentHealth(ctx context.Context, port string) error {
|
||||
request, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://127.0.0.1:"+port+"/health", nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("creating health request: %w", err)
|
||||
}
|
||||
client := &http.Client{
|
||||
Timeout: 5 * time.Second,
|
||||
Transport: &http.Transport{DisableKeepAlives: true},
|
||||
CheckRedirect: func(*http.Request, []*http.Request) error {
|
||||
return http.ErrUseLastResponse
|
||||
},
|
||||
}
|
||||
defer client.CloseIdleConnections()
|
||||
response, err := client.Do(request)
|
||||
if err != nil {
|
||||
return fmt.Errorf("requesting Agent health: %w", err)
|
||||
}
|
||||
defer response.Body.Close()
|
||||
if response.StatusCode != http.StatusOK {
|
||||
return fmt.Errorf("Agent health returned HTTP %d", response.StatusCode)
|
||||
}
|
||||
var health struct {
|
||||
HTTPStatusCode int `json:"httpStatusCode"`
|
||||
EntityStatusCode string `json:"entityStatusCode"`
|
||||
Metadata struct {
|
||||
ApplicationName string `json:"applicationName"`
|
||||
} `json:"metadata"`
|
||||
}
|
||||
if err := json.NewDecoder(io.LimitReader(response.Body, 64*1024)).Decode(&health); err != nil {
|
||||
return fmt.Errorf("decoding Agent health: %w", err)
|
||||
}
|
||||
if health.HTTPStatusCode != http.StatusOK || health.EntityStatusCode != "healthy" || health.Metadata.ApplicationName != "agent" {
|
||||
return fmt.Errorf("Agent health returned an unexpected response")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestCheckAgentHealth(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
status int
|
||||
body string
|
||||
wantOK bool
|
||||
}{
|
||||
{"healthy", 200, `{"httpStatusCode":200,"entityStatusCode":"healthy","metadata":{"applicationName":"agent"}}`, true},
|
||||
{"unhealthy status", 503, `{}`, false},
|
||||
{"redirect", 302, `{}`, false},
|
||||
{"invalid JSON", 200, `not JSON`, false},
|
||||
{"wrong service", 200, `{"httpStatusCode":200,"entityStatusCode":"healthy","metadata":{"applicationName":"other"}}`, false},
|
||||
{"unhealthy body", 200, `{"httpStatusCode":200,"entityStatusCode":"unhealthy","metadata":{"applicationName":"agent"}}`, false},
|
||||
}
|
||||
t.Setenv("HTTP_PROXY", "http://127.0.0.1:1")
|
||||
t.Setenv("NO_PROXY", "")
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path != "/health" {
|
||||
t.Errorf("path = %q, want /health", r.URL.Path)
|
||||
}
|
||||
w.Header().Set("Location", "/unexpected-redirect-target")
|
||||
w.WriteHeader(test.status)
|
||||
_, _ = w.Write([]byte(test.body))
|
||||
}))
|
||||
defer server.Close()
|
||||
_, port, err := net.SplitHostPort(server.Listener.Addr().String())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
err = checkAgentHealth(context.Background(), port)
|
||||
if (err == nil) != test.wantOK {
|
||||
t.Fatalf("checkAgentHealth() = %v, wantOK %t", err, test.wantOK)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheckAgentHealthTimesOut(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
<-r.Context().Done()
|
||||
}))
|
||||
defer server.Close()
|
||||
_, port, err := net.SplitHostPort(server.Listener.Addr().String())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 25*time.Millisecond)
|
||||
defer cancel()
|
||||
if err := checkAgentHealth(ctx, port); !errors.Is(err, context.DeadlineExceeded) {
|
||||
t.Fatalf("healthcheck error = %v, want context deadline exceeded", err)
|
||||
}
|
||||
}
|
||||
+9
-2
@@ -96,7 +96,7 @@ func main() {
|
||||
var timeout string
|
||||
var subnet string
|
||||
|
||||
flag.StringVar(&action, "action", "version", "Tell us what you want do 'run' or 'version'")
|
||||
flag.StringVar(&action, "action", "version", "Action: run, version, healthcheck, discover, or decrypt")
|
||||
flag.StringVar(&configDirectory, "config", ".", "Where is the configuration stored")
|
||||
flag.StringVar(&name, "name", "agent", "Provide a name for the agent")
|
||||
flag.StringVar(&port, "port", "80", "On which port should the agent run")
|
||||
@@ -117,7 +117,7 @@ func main() {
|
||||
// Specify the timezone of the log: "UTC" or "Local".
|
||||
timezone, _ := time.LoadLocation("CET")
|
||||
configureLogging(logLevel, logOutput, timezone)
|
||||
if action == "run" {
|
||||
if action == "run" || action == "healthcheck" {
|
||||
resolvedPort, err := resolveServerPort(port, os.Getenv("AGENT_PORT"))
|
||||
if err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
@@ -139,6 +139,13 @@ func main() {
|
||||
|
||||
switch action {
|
||||
|
||||
case "healthcheck":
|
||||
if err := checkAgentHealth(context.Background(), port); err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
"component": "healthcheck",
|
||||
"event": "healthcheck_failed",
|
||||
}).Fatal("Agent healthcheck failed")
|
||||
}
|
||||
case "version":
|
||||
{
|
||||
log.WithFields(log.Fields{
|
||||
|
||||
@@ -101,8 +101,6 @@ type Golibrtsp struct {
|
||||
Client gortsplib.Client
|
||||
clientStarted bool
|
||||
VideoDecoderMutex *sync.Mutex
|
||||
keyframeMu sync.Mutex
|
||||
keyframeReady bool
|
||||
|
||||
VideoH264Index int8
|
||||
VideoH264Media *description.Media
|
||||
@@ -815,10 +813,6 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
|
||||
}
|
||||
}
|
||||
|
||||
g.keyframeMu.Lock()
|
||||
g.keyframeReady = err == nil && g.VideoH264Media != nil && g.VideoH264Decoder != nil
|
||||
g.keyframeMu.Unlock()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
@@ -1719,10 +1713,6 @@ func (g *Golibrtsp) Close(ctxOtel context.Context) error {
|
||||
_, span := tracer.Start(ctxOtel, "Close")
|
||||
defer span.End()
|
||||
|
||||
g.keyframeMu.Lock()
|
||||
g.keyframeReady = false
|
||||
g.keyframeMu.Unlock()
|
||||
|
||||
if !g.clientStarted {
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -1,35 +0,0 @@
|
||||
package capture
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/pion/rtcp"
|
||||
)
|
||||
|
||||
func (g *Golibrtsp) RequestKeyframe() error {
|
||||
g.keyframeMu.Lock()
|
||||
defer g.keyframeMu.Unlock()
|
||||
|
||||
if !g.keyframeReady {
|
||||
return errors.New("RTSP H264 keyframe requests are unavailable")
|
||||
}
|
||||
|
||||
media, ok := g.Client.Stats().Session.Medias[g.VideoH264Media]
|
||||
if !ok {
|
||||
return errors.New("RTSP video media is not set up")
|
||||
}
|
||||
video, ok := media.Formats[g.VideoH264Forma]
|
||||
if !ok || video.InboundRTPPackets == 0 {
|
||||
return errors.New("RTSP video RTP has not arrived yet")
|
||||
}
|
||||
|
||||
// Browser and camera SSRCs differ: originate feedback on the RTSP session.
|
||||
if err := g.Client.WritePacketRTCP(g.VideoH264Media, &rtcp.PictureLossIndication{
|
||||
SenderSSRC: video.LocalSSRC,
|
||||
MediaSSRC: video.RemoteSSRC,
|
||||
}); err != nil {
|
||||
return fmt.Errorf("request camera keyframe: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -1,164 +0,0 @@
|
||||
package capture
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/bluenviron/gortsplib/v5"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/base"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/description"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/format"
|
||||
"github.com/pion/rtcp"
|
||||
"github.com/pion/rtp"
|
||||
)
|
||||
|
||||
type keyframeCamera struct {
|
||||
stream *gortsplib.ServerStream
|
||||
feedback chan rtcp.Packet
|
||||
}
|
||||
|
||||
func (c *keyframeCamera) OnDescribe(*gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
|
||||
return &base.Response{StatusCode: base.StatusOK}, c.stream, nil
|
||||
}
|
||||
|
||||
func (c *keyframeCamera) OnSetup(*gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
|
||||
return &base.Response{StatusCode: base.StatusOK}, c.stream, nil
|
||||
}
|
||||
|
||||
func (c *keyframeCamera) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
|
||||
ctx.Session.OnPacketRTCPAny(func(_ *description.Media, pkt rtcp.Packet) {
|
||||
c.feedback <- pkt
|
||||
})
|
||||
return &base.Response{StatusCode: base.StatusOK}, nil
|
||||
}
|
||||
|
||||
func connectedKeyframeCamera(t *testing.T) (*Golibrtsp, *keyframeCamera) {
|
||||
t.Helper()
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { listener.Close() })
|
||||
camera := &keyframeCamera{feedback: make(chan rtcp.Packet, 32)}
|
||||
server := &gortsplib.Server{
|
||||
RTSPAddress: "127.0.0.1:0",
|
||||
Handler: camera,
|
||||
Listen: func(string, string) (net.Listener, error) {
|
||||
return listener, nil
|
||||
},
|
||||
}
|
||||
if err := server.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(server.Close)
|
||||
media := &description.Media{
|
||||
Type: description.MediaTypeVideo,
|
||||
Formats: []format.Format{&format.H264{
|
||||
PayloadTyp: 96,
|
||||
PacketizationMode: 1,
|
||||
}},
|
||||
}
|
||||
camera.stream = &gortsplib.ServerStream{
|
||||
Server: server,
|
||||
Desc: &description.Session{Medias: []*description.Media{media}},
|
||||
}
|
||||
if err := camera.stream.Initialize(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(camera.stream.Close)
|
||||
|
||||
client := &Golibrtsp{Url: "rtsp://" + listener.Addr().String() + "/camera"}
|
||||
t.Cleanup(func() {
|
||||
if err := client.Close(context.Background()); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
if err := client.Connect(context.Background(), context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := client.RequestKeyframe(); err == nil {
|
||||
t.Fatal("requested a keyframe before the camera SSRC was known")
|
||||
}
|
||||
received := make(chan struct{}, 1)
|
||||
client.Client.OnPacketRTP(client.VideoH264Media, client.VideoH264Forma, func(*rtp.Packet) {
|
||||
received <- struct{}{}
|
||||
})
|
||||
if _, err := client.Client.Play(nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := camera.stream.WritePacketRTP(media, &rtp.Packet{
|
||||
Header: rtp.Header{
|
||||
Version: 2,
|
||||
PayloadType: 96,
|
||||
SSRC: 0x12345678,
|
||||
SequenceNumber: 1,
|
||||
Timestamp: 90000,
|
||||
Marker: true,
|
||||
},
|
||||
Payload: []byte{0x65, 0x88, 0x84},
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
select {
|
||||
case <-received:
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatal("test camera RTP did not arrive")
|
||||
}
|
||||
return client, camera
|
||||
}
|
||||
|
||||
func TestRTSPKeyframeRequestUsesCameraSessionSSRCs(t *testing.T) {
|
||||
client, camera := connectedKeyframeCamera(t)
|
||||
want := client.Client.Stats().Session.Medias[client.VideoH264Media].Formats[client.VideoH264Forma]
|
||||
if err := client.RequestKeyframe(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
select {
|
||||
case pkt := <-camera.feedback:
|
||||
pli, ok := pkt.(*rtcp.PictureLossIndication)
|
||||
if !ok {
|
||||
t.Fatalf("camera received %T, want PLI", pkt)
|
||||
}
|
||||
if pli.MediaSSRC != want.RemoteSSRC || pli.SenderSSRC != want.LocalSSRC {
|
||||
t.Fatalf("camera PLI SSRCs = sender %x media %x, want sender %x media %x",
|
||||
pli.SenderSSRC, pli.MediaSSRC, want.LocalSSRC, want.RemoteSSRC)
|
||||
}
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatal("camera did not receive RTCP PLI")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRTSPKeyframeRequestUnavailableBeforeConnectAndAfterClose(t *testing.T) {
|
||||
if err := (&Golibrtsp{}).RequestKeyframe(); err == nil {
|
||||
t.Fatal("uninitialized client accepted a keyframe request")
|
||||
}
|
||||
client, _ := connectedKeyframeCamera(t)
|
||||
if err := client.Close(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := client.RequestKeyframe(); err == nil {
|
||||
t.Fatal("closed client accepted a keyframe request")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRTSPKeyframeRequestConcurrentWithClose(t *testing.T) {
|
||||
client, _ := connectedKeyframeCamera(t)
|
||||
var wg sync.WaitGroup
|
||||
for range 4 {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for range 5 {
|
||||
// Requests may race with Close and legitimately become unavailable.
|
||||
_ = client.RequestKeyframe()
|
||||
}
|
||||
}()
|
||||
}
|
||||
if err := client.Close(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
wg.Wait()
|
||||
}
|
||||
@@ -72,10 +72,6 @@ func (c *Capture) ClearClients(main, sub, backchannel *Golibrtsp) {
|
||||
}
|
||||
}
|
||||
|
||||
type KeyframeRequester interface {
|
||||
RequestKeyframe() error
|
||||
}
|
||||
|
||||
// RTSPClient is a interface that abstracts the RTSP client implementation.
|
||||
type RTSPClient interface {
|
||||
// Connect to the RTSP server.
|
||||
|
||||
@@ -1285,7 +1285,7 @@ func HandleLiveStreamHD(
|
||||
// viewer can pick the resolution it needs per peer connection without
|
||||
// the agent re-negotiating the RTSP source.
|
||||
mainStreams, _ := rtspClient.GetStreams()
|
||||
mainVideoBroadcaster := webrtc.NewVideoBroadcaster(mainStreams, rtspClient)
|
||||
mainVideoBroadcaster := webrtc.NewVideoBroadcaster(mainStreams)
|
||||
mainAudioBroadcaster := webrtc.NewAudioBroadcaster(mainStreams)
|
||||
|
||||
if mainVideoBroadcaster == nil && mainAudioBroadcaster == nil {
|
||||
@@ -1316,7 +1316,7 @@ func HandleLiveStreamHD(
|
||||
var subAudioBroadcaster *webrtc.TrackBroadcaster
|
||||
if subStreamEnabled && rtspSubClient != nil && subQueue != nil {
|
||||
subStreams, _ := rtspSubClient.GetStreams()
|
||||
subVideoBroadcaster = webrtc.NewVideoBroadcaster(subStreams, rtspSubClient)
|
||||
subVideoBroadcaster = webrtc.NewVideoBroadcaster(subStreams)
|
||||
subAudioBroadcaster = webrtc.NewAudioBroadcaster(subStreams)
|
||||
defer func() {
|
||||
if subVideoBroadcaster != nil {
|
||||
|
||||
@@ -83,18 +83,11 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
|
||||
// Add all routes
|
||||
AddRoutes(r, authMiddleware, configDirectory, configuration, communication, captureDevice)
|
||||
|
||||
// Update environment variables
|
||||
environmentVariables := configDirectory + "/www/env.js"
|
||||
if os.Getenv("AGENT_MODE") == "demo" {
|
||||
demoEnvironmentVariables := configDirectory + "/www/env.demo.js"
|
||||
// Move demo environment variables to environment variables
|
||||
err := os.Rename(demoEnvironmentVariables, environmentVariables)
|
||||
if err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "demo_environment_move_failed",
|
||||
}).Fatal("Failed to activate demo UI environment")
|
||||
}
|
||||
if err := addUIEnvironmentRoute(r, configDirectory); err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "ui_environment_unavailable",
|
||||
}).Fatal("Failed to load UI environment")
|
||||
}
|
||||
|
||||
// Add static routes to UI
|
||||
@@ -123,6 +116,20 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
|
||||
}
|
||||
}
|
||||
|
||||
func addUIEnvironmentRoute(router *gin.Engine, configDirectory string) error {
|
||||
environmentFile := configDirectory + "/www/env.js"
|
||||
if os.Getenv("AGENT_MODE") == "demo" {
|
||||
environmentFile = configDirectory + "/www/env.demo.js"
|
||||
}
|
||||
if _, err := os.Stat(environmentFile); err != nil {
|
||||
return fmt.Errorf("loading UI environment: %w", err)
|
||||
}
|
||||
router.Match([]string{"GET", "HEAD"}, "/env.js", func(c *gin.Context) {
|
||||
c.File(environmentFile)
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func requestLogger() gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
startedAt := time.Now()
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
package http
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
func TestUIEnvironmentIsServedWithoutChangingAssets(t *testing.T) {
|
||||
for _, mode := range []string{"", "demo"} {
|
||||
t.Run(mode, func(t *testing.T) {
|
||||
t.Setenv("AGENT_MODE", mode)
|
||||
directory := t.TempDir()
|
||||
www := filepath.Join(directory, "www")
|
||||
if err := os.Mkdir(www, 0755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for name, content := range map[string]string{"env.js": "normal", "env.demo.js": "demo"} {
|
||||
if err := os.WriteFile(filepath.Join(www, name), []byte(content), 0444); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
router := gin.New()
|
||||
if err := addUIEnvironmentRoute(router, directory); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := "normal"
|
||||
if mode == "demo" {
|
||||
want = "demo"
|
||||
}
|
||||
for _, method := range []string{http.MethodGet, http.MethodHead} {
|
||||
response := httptest.NewRecorder()
|
||||
router.ServeHTTP(response, httptest.NewRequest(method, "/env.js", nil))
|
||||
if response.Code != http.StatusOK {
|
||||
t.Fatalf("%s /env.js: status %d", method, response.Code)
|
||||
}
|
||||
if method == http.MethodGet && response.Body.String() != want {
|
||||
t.Fatalf("environment = %q, want %q", response.Body.String(), want)
|
||||
}
|
||||
if method == http.MethodHead && response.Body.Len() != 0 {
|
||||
t.Fatal("HEAD returned a response body")
|
||||
}
|
||||
}
|
||||
for name, want := range map[string]string{"env.js": "normal", "env.demo.js": "demo"} {
|
||||
got, err := os.ReadFile(filepath.Join(www, name))
|
||||
if err != nil || string(got) != want {
|
||||
t.Fatalf("asset %s changed: %q, %v", name, got, err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUIEnvironmentRejectsMissingAsset(t *testing.T) {
|
||||
t.Setenv("AGENT_MODE", "demo")
|
||||
if err := addUIEnvironmentRoute(gin.New(), t.TempDir()); err == nil {
|
||||
t.Fatal("missing demo environment was accepted")
|
||||
}
|
||||
}
|
||||
@@ -3,9 +3,7 @@ package webrtc
|
||||
import (
|
||||
"io"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/pion/rtcp"
|
||||
pionWebRTC "github.com/pion/webrtc/v4"
|
||||
pionMedia "github.com/pion/webrtc/v4/pkg/media"
|
||||
log "github.com/sirupsen/logrus"
|
||||
@@ -14,23 +12,14 @@ import (
|
||||
const (
|
||||
// peerSampleBuffer controls how many samples can be buffered per peer before
|
||||
// dropping. Keeps slow peers from blocking the broadcaster.
|
||||
peerSampleBuffer = 60
|
||||
keyframeRequestInterval = time.Second
|
||||
peerSampleBuffer = 60
|
||||
)
|
||||
|
||||
type peerSample struct {
|
||||
pionMedia.Sample
|
||||
skippedDuration time.Duration
|
||||
}
|
||||
|
||||
// peerTrack is a per-peer track with its own non-blocking sample channel.
|
||||
type peerTrack struct {
|
||||
track *pionWebRTC.TrackLocalStaticSample
|
||||
samples chan peerSample
|
||||
done chan struct{}
|
||||
connected bool
|
||||
needsKeyframe bool
|
||||
skippedDuration time.Duration
|
||||
track *pionWebRTC.TrackLocalStaticSample
|
||||
samples chan pionMedia.Sample
|
||||
done chan struct{}
|
||||
}
|
||||
|
||||
// TrackBroadcaster fans out media samples to multiple peer-specific tracks
|
||||
@@ -38,17 +27,11 @@ type peerTrack struct {
|
||||
// goroutine that drains samples independently, so a slow/congested peer
|
||||
// cannot stall the others.
|
||||
type TrackBroadcaster struct {
|
||||
mu sync.RWMutex
|
||||
peers map[string]*peerTrack
|
||||
mimeType string
|
||||
id string
|
||||
streamID string
|
||||
requestKeyframe func() error
|
||||
requestTimer *time.Timer
|
||||
requestInFlight bool
|
||||
lastRequest time.Time
|
||||
requests sync.WaitGroup
|
||||
closed bool
|
||||
mu sync.RWMutex
|
||||
peers map[string]*peerTrack
|
||||
mimeType string
|
||||
id string
|
||||
streamID string
|
||||
}
|
||||
|
||||
// NewTrackBroadcaster creates a new broadcaster for either video or audio.
|
||||
@@ -74,18 +57,12 @@ func (b *TrackBroadcaster) AddPeer(sessionKey string) (*pionWebRTC.TrackLocalSta
|
||||
}
|
||||
|
||||
pt := &peerTrack{
|
||||
track: track,
|
||||
samples: make(chan peerSample, peerSampleBuffer),
|
||||
done: make(chan struct{}),
|
||||
connected: b.mimeType != pionWebRTC.MimeTypeH264,
|
||||
needsKeyframe: b.mimeType == pionWebRTC.MimeTypeH264,
|
||||
track: track,
|
||||
samples: make(chan pionMedia.Sample, peerSampleBuffer),
|
||||
done: make(chan struct{}),
|
||||
}
|
||||
|
||||
b.mu.Lock()
|
||||
if b.closed {
|
||||
b.mu.Unlock()
|
||||
return nil, io.ErrClosedPipe
|
||||
}
|
||||
b.peers[sessionKey] = pt
|
||||
b.mu.Unlock()
|
||||
|
||||
@@ -93,7 +70,7 @@ func (b *TrackBroadcaster) AddPeer(sessionKey string) (*pionWebRTC.TrackLocalSta
|
||||
go func() {
|
||||
defer close(pt.done)
|
||||
for sample := range pt.samples {
|
||||
if err := writePeerSample(pt.track, sample); err != nil {
|
||||
if err := pt.track.WriteSample(sample); err != nil {
|
||||
if err == io.ErrClosedPipe {
|
||||
return
|
||||
}
|
||||
@@ -114,16 +91,6 @@ func (b *TrackBroadcaster) AddPeer(sessionKey string) (*pionWebRTC.TrackLocalSta
|
||||
return track, nil
|
||||
}
|
||||
|
||||
func writePeerSample(track *pionWebRTC.TrackLocalStaticSample, sample peerSample) error {
|
||||
if sample.skippedDuration > 0 {
|
||||
// An empty sample advances Pion's RTP clock without sending a packet.
|
||||
if err := track.WriteSample(pionMedia.Sample{Duration: sample.skippedDuration}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return track.WriteSample(sample.Sample)
|
||||
}
|
||||
|
||||
// RemovePeer stops the writer goroutine and removes the peer.
|
||||
func (b *TrackBroadcaster) RemovePeer(sessionKey string) {
|
||||
b.mu.Lock()
|
||||
@@ -147,37 +114,14 @@ func (b *TrackBroadcaster) RemovePeer(sessionKey string) {
|
||||
// WriteSample fans out a sample to all connected peers without blocking.
|
||||
// If a peer's buffer is full (slow consumer), the sample is dropped for
|
||||
// that peer only — other peers are unaffected.
|
||||
func (b *TrackBroadcaster) WriteSample(sample pionMedia.Sample, isKeyframe bool) {
|
||||
b.mu.Lock()
|
||||
defer b.mu.Unlock()
|
||||
if b.closed {
|
||||
return
|
||||
}
|
||||
func (b *TrackBroadcaster) WriteSample(sample pionMedia.Sample) {
|
||||
b.mu.RLock()
|
||||
defer b.mu.RUnlock()
|
||||
|
||||
for sessionKey, pt := range b.peers {
|
||||
video := b.mimeType == pionWebRTC.MimeTypeH264
|
||||
if video && (!pt.connected || (pt.needsKeyframe && !isKeyframe)) {
|
||||
pt.skippedDuration += sample.Duration
|
||||
continue
|
||||
}
|
||||
select {
|
||||
case pt.samples <- peerSample{Sample: sample, skippedDuration: pt.skippedDuration}:
|
||||
pt.skippedDuration = 0
|
||||
if video && isKeyframe {
|
||||
pt.needsKeyframe = false
|
||||
}
|
||||
case pt.samples <- sample:
|
||||
default:
|
||||
if video {
|
||||
pt.needsKeyframe = true
|
||||
drainPeerSamples(pt)
|
||||
if isKeyframe {
|
||||
pt.samples <- peerSample{Sample: sample, skippedDuration: pt.skippedDuration}
|
||||
pt.skippedDuration = 0
|
||||
pt.needsKeyframe = false
|
||||
} else {
|
||||
pt.skippedDuration += sample.Duration
|
||||
}
|
||||
}
|
||||
log.WithFields(log.Fields{
|
||||
"component": "webrtc",
|
||||
"event": "slow_peer_sample_dropped",
|
||||
@@ -185,106 +129,6 @@ func (b *TrackBroadcaster) WriteSample(sample pionMedia.Sample, isKeyframe bool)
|
||||
}).Warn("Dropping WebRTC sample for slow peer")
|
||||
}
|
||||
}
|
||||
b.scheduleKeyframeRequestLocked()
|
||||
}
|
||||
|
||||
func drainPeerSamples(pt *peerTrack) {
|
||||
for {
|
||||
select {
|
||||
case sample := <-pt.samples:
|
||||
pt.skippedDuration += sample.skippedDuration + sample.Duration
|
||||
default:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (b *TrackBroadcaster) SetPeerConnected(sessionKey string, connected bool) {
|
||||
b.mu.Lock()
|
||||
defer b.mu.Unlock()
|
||||
|
||||
pt, ok := b.peers[sessionKey]
|
||||
if !ok || b.mimeType != pionWebRTC.MimeTypeH264 || pt.connected == connected {
|
||||
return
|
||||
}
|
||||
pt.connected = connected
|
||||
pt.needsKeyframe = true
|
||||
drainPeerSamples(pt)
|
||||
b.scheduleKeyframeRequestLocked()
|
||||
}
|
||||
|
||||
func (b *TrackBroadcaster) HandleRTCP(sessionKey string, data []byte) error {
|
||||
feedback, err := rtcp.Unmarshal(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, packet := range feedback {
|
||||
switch packet.(type) {
|
||||
case *rtcp.PictureLossIndication, *rtcp.FullIntraRequest:
|
||||
b.mu.Lock()
|
||||
if pt, ok := b.peers[sessionKey]; ok && pt.connected && b.mimeType == pionWebRTC.MimeTypeH264 {
|
||||
pt.needsKeyframe = true
|
||||
drainPeerSamples(pt)
|
||||
b.scheduleKeyframeRequestLocked()
|
||||
}
|
||||
b.mu.Unlock()
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (b *TrackBroadcaster) waitingForKeyframeLocked() bool {
|
||||
for _, pt := range b.peers {
|
||||
if pt.connected && pt.needsKeyframe {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (b *TrackBroadcaster) scheduleKeyframeRequestLocked() {
|
||||
if b.closed || b.requestKeyframe == nil || b.requestInFlight || !b.waitingForKeyframeLocked() {
|
||||
return
|
||||
}
|
||||
if b.requestTimer == nil {
|
||||
delay := time.Until(b.lastRequest.Add(keyframeRequestInterval))
|
||||
if delay < 0 {
|
||||
delay = 0
|
||||
}
|
||||
b.requestTimer = time.AfterFunc(delay, b.sendKeyframeRequest)
|
||||
}
|
||||
}
|
||||
|
||||
func (b *TrackBroadcaster) sendKeyframeRequest() {
|
||||
b.mu.Lock()
|
||||
b.requestTimer = nil
|
||||
if b.closed || !b.waitingForKeyframeLocked() {
|
||||
b.mu.Unlock()
|
||||
return
|
||||
}
|
||||
b.lastRequest = time.Now()
|
||||
b.requestInFlight = true
|
||||
b.requests.Add(1)
|
||||
b.mu.Unlock()
|
||||
defer b.requests.Done()
|
||||
|
||||
if err := b.requestKeyframe(); err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
"component": "webrtc",
|
||||
"event": "keyframe_request_failed",
|
||||
}).Warn("Camera keyframe request failed; waiting for a periodic IDR")
|
||||
} else {
|
||||
log.WithFields(log.Fields{
|
||||
"component": "webrtc",
|
||||
"event": "keyframe_requested",
|
||||
}).Debug("Requested camera keyframe")
|
||||
}
|
||||
|
||||
b.mu.Lock()
|
||||
b.requestInFlight = false
|
||||
b.scheduleKeyframeRequestLocked()
|
||||
b.mu.Unlock()
|
||||
}
|
||||
|
||||
// PeerCount returns the current number of connected peers.
|
||||
@@ -297,17 +141,11 @@ func (b *TrackBroadcaster) PeerCount() int {
|
||||
// Close removes all peers and stops all writer goroutines.
|
||||
func (b *TrackBroadcaster) Close() {
|
||||
b.mu.Lock()
|
||||
b.closed = true
|
||||
if b.requestTimer != nil {
|
||||
b.requestTimer.Stop()
|
||||
b.requestTimer = nil
|
||||
}
|
||||
keys := make([]string, 0, len(b.peers))
|
||||
for k := range b.peers {
|
||||
keys = append(keys, k)
|
||||
}
|
||||
b.mu.Unlock()
|
||||
b.requests.Wait()
|
||||
|
||||
for _, key := range keys {
|
||||
b.RemovePeer(key)
|
||||
|
||||
@@ -1,360 +0,0 @@
|
||||
package webrtc
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/kerberos-io/agent/machinery/src/capture"
|
||||
"github.com/kerberos-io/agent/machinery/src/models"
|
||||
"github.com/kerberos-io/agent/machinery/src/packets"
|
||||
"github.com/pion/rtcp"
|
||||
pionWebRTC "github.com/pion/webrtc/v4"
|
||||
pionMedia "github.com/pion/webrtc/v4/pkg/media"
|
||||
)
|
||||
|
||||
func bufferedTestPeer(capacity int) *peerTrack {
|
||||
done := make(chan struct{})
|
||||
close(done)
|
||||
return &peerTrack{
|
||||
samples: make(chan peerSample, capacity),
|
||||
done: done,
|
||||
needsKeyframe: true,
|
||||
}
|
||||
}
|
||||
|
||||
func testVideoBroadcaster(t *testing.T) (*TrackBroadcaster, *peerTrack) {
|
||||
t.Helper()
|
||||
b := NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", "test")
|
||||
pt := bufferedTestPeer(peerSampleBuffer)
|
||||
b.peers["viewer"] = pt
|
||||
t.Cleanup(b.Close)
|
||||
return b, pt
|
||||
}
|
||||
|
||||
func TestVideoPeerStartsAndReconnectsAtKeyframe(t *testing.T) {
|
||||
b, pt := testVideoBroadcaster(t)
|
||||
sample := pionMedia.Sample{Data: []byte{1}}
|
||||
b.WriteSample(sample, true)
|
||||
if len(pt.samples) != 0 {
|
||||
t.Fatal("sent a keyframe before the transport connected")
|
||||
}
|
||||
|
||||
b.SetPeerConnected("viewer", true)
|
||||
b.WriteSample(sample, false)
|
||||
if len(pt.samples) != 0 {
|
||||
t.Fatal("sent a dependent frame before the first IDR")
|
||||
}
|
||||
b.WriteSample(sample, true)
|
||||
b.WriteSample(sample, false)
|
||||
if len(pt.samples) != 2 || pt.needsKeyframe {
|
||||
t.Fatal("did not release video after the first IDR")
|
||||
}
|
||||
|
||||
b.SetPeerConnected("viewer", false)
|
||||
b.WriteSample(sample, true)
|
||||
if len(pt.samples) != 0 {
|
||||
t.Fatal("retained or sent video while disconnected")
|
||||
}
|
||||
b.SetPeerConnected("viewer", true)
|
||||
b.WriteSample(sample, false)
|
||||
if len(pt.samples) != 0 {
|
||||
t.Fatal("reconnected viewer resumed on a dependent frame")
|
||||
}
|
||||
b.WriteSample(sample, true)
|
||||
if len(pt.samples) != 1 {
|
||||
t.Fatal("reconnected viewer did not resume at an IDR")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLateViewerDoesNotResetExistingViewer(t *testing.T) {
|
||||
b, first := testVideoBroadcaster(t)
|
||||
b.SetPeerConnected("viewer", true)
|
||||
b.WriteSample(pionMedia.Sample{}, true)
|
||||
<-first.samples
|
||||
|
||||
late := bufferedTestPeer(peerSampleBuffer)
|
||||
b.peers["late"] = late
|
||||
b.SetPeerConnected("late", true)
|
||||
b.WriteSample(pionMedia.Sample{}, false)
|
||||
if len(first.samples) != 1 || len(late.samples) != 0 {
|
||||
t.Fatal("late viewer either interrupted an existing viewer or received a dependent frame")
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{}, true)
|
||||
if len(late.samples) != 1 {
|
||||
t.Fatal("late viewer did not receive the next IDR")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVideoFeedbackRequestsFreshKeyframe(t *testing.T) {
|
||||
for _, feedback := range []rtcp.Packet{
|
||||
&rtcp.PictureLossIndication{MediaSSRC: 123},
|
||||
&rtcp.FullIntraRequest{FIR: []rtcp.FIREntry{{SSRC: 123, SequenceNumber: 1}}},
|
||||
} {
|
||||
t.Run(fmt.Sprintf("%T", feedback), func(t *testing.T) {
|
||||
b, pt := testVideoBroadcaster(t)
|
||||
b.SetPeerConnected("viewer", true)
|
||||
b.WriteSample(pionMedia.Sample{}, true)
|
||||
b.WriteSample(pionMedia.Sample{}, false)
|
||||
|
||||
rr, err := rtcp.Marshal([]rtcp.Packet{&rtcp.ReceiverReport{}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := b.HandleRTCP("viewer", rr); err != nil || len(pt.samples) != 2 {
|
||||
t.Fatal("receiver report reset the video gate", err)
|
||||
}
|
||||
data, err := rtcp.Marshal([]rtcp.Packet{&rtcp.ReceiverReport{}, feedback})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := b.HandleRTCP("viewer", data); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{}, false)
|
||||
if len(pt.samples) != 0 || !pt.needsKeyframe {
|
||||
t.Fatal("PLI/FIR did not discard stale queued frames and wait for an IDR")
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{}, true)
|
||||
if len(pt.samples) != 1 {
|
||||
t.Fatal("PLI/FIR recovery did not resume at an IDR")
|
||||
}
|
||||
if err := b.HandleRTCP("viewer", []byte{0}); err == nil {
|
||||
t.Fatal("malformed RTCP was accepted")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSlowVideoPeerRecoversWithoutBlockingOthers(t *testing.T) {
|
||||
for _, overflowIsKeyframe := range []bool{false, true} {
|
||||
t.Run(map[bool]string{false: "dependent-frame-dropped", true: "new-IDR-replaces-backlog"}[overflowIsKeyframe], func(t *testing.T) {
|
||||
b, fast := testVideoBroadcaster(t)
|
||||
slow := bufferedTestPeer(2)
|
||||
b.peers["slow"] = slow
|
||||
b.SetPeerConnected("viewer", true)
|
||||
b.SetPeerConnected("slow", true)
|
||||
b.WriteSample(pionMedia.Sample{}, true)
|
||||
b.WriteSample(pionMedia.Sample{}, false)
|
||||
b.WriteSample(pionMedia.Sample{}, overflowIsKeyframe)
|
||||
if len(fast.samples) != 3 {
|
||||
t.Fatal("slow viewer interrupted another viewer")
|
||||
}
|
||||
if overflowIsKeyframe {
|
||||
if len(slow.samples) != 1 || slow.needsKeyframe {
|
||||
t.Fatal("fresh IDR did not replace the stale backlog")
|
||||
}
|
||||
} else {
|
||||
b.WriteSample(pionMedia.Sample{}, false)
|
||||
if len(slow.samples) != 0 || !slow.needsKeyframe {
|
||||
t.Fatal("slow viewer forwarded dependent frames after a drop")
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{}, true)
|
||||
if len(slow.samples) != 1 {
|
||||
t.Fatal("slow viewer did not recover at the next IDR")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAudioDoesNotWaitForVideoKeyframe(t *testing.T) {
|
||||
b := NewTrackBroadcaster(pionWebRTC.MimeTypePCMU, "audio", "test")
|
||||
pt := bufferedTestPeer(2)
|
||||
pt.connected = true
|
||||
pt.needsKeyframe = false
|
||||
b.peers["viewer"] = pt
|
||||
t.Cleanup(b.Close)
|
||||
|
||||
b.SetPeerConnected("viewer", false)
|
||||
for range 3 {
|
||||
b.WriteSample(pionMedia.Sample{}, false)
|
||||
}
|
||||
if len(pt.samples) != 2 {
|
||||
t.Fatal("audio queue behavior changed")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVideoSampleBufferPreservesKeyframeFlag(t *testing.T) {
|
||||
b, pt := testVideoBroadcaster(t)
|
||||
b.SetPeerConnected("viewer", true)
|
||||
state := &streamState{}
|
||||
first := packets.Packet{Data: []byte{0x65}, IsKeyFrame: true, Time: 1}
|
||||
processVideoPacket(first, state, b, models.Config{})
|
||||
processVideoPacket(packets.Packet{Data: []byte{0x41}, Time: 34}, state, b, models.Config{})
|
||||
if len(pt.samples) != 1 || !bytes.Equal((<-pt.samples).Data, first.Data) {
|
||||
t.Fatal("buffered IDR lost its keyframe flag")
|
||||
}
|
||||
|
||||
b.SetPeerConnected("viewer", false)
|
||||
b.SetPeerConnected("viewer", true)
|
||||
writeFinalSamples(state, b, nil)
|
||||
if len(pt.samples) != 0 {
|
||||
t.Fatal("final dependent frame was mislabeled as an IDR")
|
||||
}
|
||||
state.lastVideoSample = &pionMedia.Sample{Data: first.Data}
|
||||
state.lastVideoKeyframe = true
|
||||
writeFinalSamples(state, b, nil)
|
||||
if len(pt.samples) != 1 {
|
||||
t.Fatal("final IDR lost its keyframe flag")
|
||||
}
|
||||
}
|
||||
|
||||
func TestKeyframeRequestsCoalesceAndRetryUntilIDR(t *testing.T) {
|
||||
b, _ := testVideoBroadcaster(t)
|
||||
calls := make(chan time.Time, 10)
|
||||
var count atomic.Int32
|
||||
b.requestKeyframe = func() error {
|
||||
calls <- time.Now()
|
||||
if count.Add(1) == 1 {
|
||||
return errors.New("camera is not ready yet")
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{}, true)
|
||||
return nil
|
||||
}
|
||||
for _, id := range []string{"viewer", "second", "third"} {
|
||||
if id != "viewer" {
|
||||
b.mu.Lock()
|
||||
b.peers[id] = bufferedTestPeer(peerSampleBuffer)
|
||||
b.mu.Unlock()
|
||||
}
|
||||
b.SetPeerConnected(id, true)
|
||||
}
|
||||
var first time.Time
|
||||
select {
|
||||
case first = <-calls:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("connected viewer did not request a keyframe")
|
||||
}
|
||||
feedback, err := rtcp.Marshal([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: 123}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for range 100 {
|
||||
if err := b.HandleRTCP("viewer", feedback); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
select {
|
||||
case second := <-calls:
|
||||
if second.Sub(first) < keyframeRequestInterval-5*time.Millisecond {
|
||||
t.Fatal("feedback bypassed the per-stream request rate limit")
|
||||
}
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("failed camera request was not retried")
|
||||
}
|
||||
select {
|
||||
case <-calls:
|
||||
t.Fatal("requests continued after all viewers received an IDR")
|
||||
case <-time.After(keyframeRequestInterval + 100*time.Millisecond):
|
||||
}
|
||||
}
|
||||
|
||||
func TestKeyframeRequestsStopOnDisconnectAndClose(t *testing.T) {
|
||||
b, _ := testVideoBroadcaster(t)
|
||||
var calls atomic.Int32
|
||||
b.requestKeyframe = func() error { calls.Add(1); return nil }
|
||||
b.lastRequest = time.Now()
|
||||
b.SetPeerConnected("viewer", true)
|
||||
b.SetPeerConnected("viewer", false)
|
||||
time.Sleep(keyframeRequestInterval + 50*time.Millisecond)
|
||||
if calls.Load() != 0 {
|
||||
t.Fatal("disconnected viewer requested a keyframe")
|
||||
}
|
||||
b.SetPeerConnected("viewer", true)
|
||||
b.Close()
|
||||
if _, err := b.AddPeer("closed"); !errors.Is(err, io.ErrClosedPipe) {
|
||||
t.Fatalf("AddPeer() after Close() = %v, want closed pipe", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBroadcasterCloseWaitsForKeyframeRequest(t *testing.T) {
|
||||
b, _ := testVideoBroadcaster(t)
|
||||
started, release, closed := make(chan struct{}), make(chan struct{}), make(chan struct{})
|
||||
unblock := sync.OnceFunc(func() { close(release) })
|
||||
defer unblock()
|
||||
b.requestKeyframe = func() error {
|
||||
close(started)
|
||||
<-release
|
||||
return nil
|
||||
}
|
||||
b.SetPeerConnected("viewer", true)
|
||||
select {
|
||||
case <-started:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("request did not start")
|
||||
}
|
||||
go func() { b.Close(); close(closed) }()
|
||||
select {
|
||||
case <-closed:
|
||||
t.Fatal("Close returned before the in-flight camera request completed")
|
||||
case <-time.After(30 * time.Millisecond):
|
||||
}
|
||||
unblock()
|
||||
select {
|
||||
case <-closed:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("Close did not finish")
|
||||
}
|
||||
}
|
||||
|
||||
func TestConcurrentVideoFeedbackAndPeerLifecycle(t *testing.T) {
|
||||
b := NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", "test")
|
||||
t.Cleanup(b.Close)
|
||||
data, err := rtcp.Marshal([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: 123}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var wg sync.WaitGroup
|
||||
for _, id := range []string{"first", "second", "third"} {
|
||||
if _, err := b.AddPeer(id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for j := range 200 {
|
||||
b.SetPeerConnected(id, j%5 != 0)
|
||||
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x65}, Duration: time.Millisecond}, j%10 == 0)
|
||||
if err := b.HandleRTCP(id, data); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
b.RemovePeer(id)
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
type keyframeTestSource struct {
|
||||
capture.RTSPClient
|
||||
request func() error
|
||||
}
|
||||
|
||||
func (s keyframeTestSource) RequestKeyframe() error { return s.request() }
|
||||
|
||||
func TestVideoBroadcastersRequestTheirOwnSource(t *testing.T) {
|
||||
streams := []packets.Stream{{Name: "H264", IsVideo: true}}
|
||||
var mainCalls, subCalls atomic.Int32
|
||||
main := NewVideoBroadcaster(streams, keyframeTestSource{request: func() error { mainCalls.Add(1); return nil }})
|
||||
sub := NewVideoBroadcaster(streams, keyframeTestSource{request: func() error { subCalls.Add(1); return nil }})
|
||||
t.Cleanup(main.Close)
|
||||
t.Cleanup(sub.Close)
|
||||
if err := main.requestKeyframe(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if mainCalls.Load() != 1 || subCalls.Load() != 0 {
|
||||
t.Fatal("main feedback reached the wrong source")
|
||||
}
|
||||
if err := sub.requestKeyframe(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if mainCalls.Load() != 1 || subCalls.Load() != 1 {
|
||||
t.Fatal("sub feedback reached the wrong source")
|
||||
}
|
||||
}
|
||||
@@ -18,6 +18,7 @@ import (
|
||||
|
||||
mqtt "github.com/eclipse/paho.mqtt.golang"
|
||||
"github.com/pion/interceptor"
|
||||
"github.com/pion/interceptor/pkg/intervalpli"
|
||||
pionWebRTC "github.com/pion/webrtc/v4"
|
||||
pionMedia "github.com/pion/webrtc/v4/pkg/media"
|
||||
)
|
||||
@@ -428,6 +429,16 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// Register a intervalpli factory
|
||||
// This interceptor sends a PLI every 3 seconds. A PLI causes a video keyframe to be generated by the sender.
|
||||
// This makes our video seekable and more error resilent, but at a cost of lower picture quality and higher bitrates
|
||||
// A real world application should process incoming RTCP packets from viewers and forward them to senders
|
||||
intervalPliFactory, err := intervalpli.NewReceiverInterceptor()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
interceptorRegistry.Add(intervalPliFactory)
|
||||
|
||||
api := pionWebRTC.NewAPI(
|
||||
pionWebRTC.WithMediaEngine(mediaEngine),
|
||||
pionWebRTC.WithInterceptorRegistry(interceptorRegistry),
|
||||
@@ -508,16 +519,9 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
|
||||
case <-ctx.Done():
|
||||
return
|
||||
default:
|
||||
n, _, rtcpErr := videoSender.Read(rtcpBuf)
|
||||
if rtcpErr != nil {
|
||||
if ctx.Err() == nil && rtcpErr != io.EOF && rtcpErr != io.ErrClosedPipe {
|
||||
log.WithError(rtcpErr).Warn("WebRTC video RTCP reader failed")
|
||||
}
|
||||
if _, _, rtcpErr := videoSender.Read(rtcpBuf); rtcpErr != nil {
|
||||
return
|
||||
}
|
||||
if err := videoBroadcaster.HandleRTCP(sessionKey, rtcpBuf[:n]); err != nil {
|
||||
log.WithError(err).Warn("Ignoring malformed WebRTC video RTCP feedback")
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
@@ -576,9 +580,6 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
|
||||
|
||||
switch connectionState {
|
||||
case pionWebRTC.PeerConnectionStateDisconnected:
|
||||
if videoBroadcaster != nil {
|
||||
videoBroadcaster.SetPeerConnected(sessionKey, false)
|
||||
}
|
||||
// Disconnected is a transient state that can recover.
|
||||
// Start a grace period timer; if we don't recover, then cleanup.
|
||||
wrapper.disconnectMu.Lock()
|
||||
@@ -618,9 +619,6 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
|
||||
cleanupPeerConnection(sessionKey, wrapper)
|
||||
|
||||
case pionWebRTC.PeerConnectionStateConnected:
|
||||
if videoBroadcaster != nil {
|
||||
videoBroadcaster.SetPeerConnected(sessionKey, true)
|
||||
}
|
||||
// Cancel any pending disconnect timer — connection recovered
|
||||
wrapper.disconnectMu.Lock()
|
||||
if wrapper.disconnectTimer != nil {
|
||||
@@ -762,17 +760,11 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
|
||||
}
|
||||
}
|
||||
|
||||
func NewVideoBroadcaster(streams []packets.Stream, rtspClient capture.RTSPClient) *TrackBroadcaster {
|
||||
func NewVideoBroadcaster(streams []packets.Stream) *TrackBroadcaster {
|
||||
// Verify H264 is available (same check as NewVideoTrack)
|
||||
for _, s := range streams {
|
||||
if s.Name == "H264" {
|
||||
b := NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", trackStreamID)
|
||||
if requester, ok := rtspClient.(capture.KeyframeRequester); ok {
|
||||
b.requestKeyframe = requester.RequestKeyframe
|
||||
} else {
|
||||
log.Warn("RTSP source does not support keyframe requests; waiting for periodic IDRs")
|
||||
}
|
||||
return b
|
||||
return NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", trackStreamID)
|
||||
}
|
||||
}
|
||||
log.Error("webrtc.main.NewVideoBroadcaster(): no H264 stream found")
|
||||
@@ -866,19 +858,18 @@ func NewAudioTrack(streams []packets.Stream) *pionWebRTC.TrackLocalStaticSample
|
||||
|
||||
// streamState holds state information for the streaming process
|
||||
type streamState struct {
|
||||
lastKeepAlive int64
|
||||
peerCount int64
|
||||
start bool
|
||||
catchingUp bool
|
||||
receivedKeyFrame bool
|
||||
lastAudioSample *pionMedia.Sample
|
||||
lastVideoSample *pionMedia.Sample
|
||||
lastVideoKeyframe bool
|
||||
audioPacketsSeen int64
|
||||
aacPacketsSeen int64
|
||||
audioSamplesSent int64
|
||||
aacNoOutput int64
|
||||
aacErrors int64
|
||||
lastKeepAlive int64
|
||||
peerCount int64
|
||||
start bool
|
||||
catchingUp bool
|
||||
receivedKeyFrame bool
|
||||
lastAudioSample *pionMedia.Sample
|
||||
lastVideoSample *pionMedia.Sample
|
||||
audioPacketsSeen int64
|
||||
aacPacketsSeen int64
|
||||
audioSamplesSent int64
|
||||
aacNoOutput int64
|
||||
aacErrors int64
|
||||
}
|
||||
|
||||
// codecSupport tracks which codecs are available in the stream
|
||||
@@ -952,11 +943,11 @@ func updateStreamState(communication *models.Communication, state *streamState)
|
||||
// writeFinalSamples writes any remaining buffered samples
|
||||
func writeFinalSamples(state *streamState, videoBroadcaster, audioBroadcaster *TrackBroadcaster) {
|
||||
if state.lastVideoSample != nil && videoBroadcaster != nil {
|
||||
videoBroadcaster.WriteSample(*state.lastVideoSample, state.lastVideoKeyframe)
|
||||
videoBroadcaster.WriteSample(*state.lastVideoSample)
|
||||
}
|
||||
|
||||
if state.lastAudioSample != nil && audioBroadcaster != nil {
|
||||
audioBroadcaster.WriteSample(*state.lastAudioSample, false)
|
||||
audioBroadcaster.WriteSample(*state.lastAudioSample)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1020,11 +1011,10 @@ func processVideoPacket(pkt packets.Packet, state *streamState, videoBroadcaster
|
||||
|
||||
if state.lastVideoSample != nil {
|
||||
state.lastVideoSample.Duration = sampleDuration(pkt, state.lastVideoSample.PacketTimestamp, 33*time.Millisecond)
|
||||
videoBroadcaster.WriteSample(*state.lastVideoSample, state.lastVideoKeyframe)
|
||||
videoBroadcaster.WriteSample(*state.lastVideoSample)
|
||||
}
|
||||
|
||||
state.lastVideoSample = &sample
|
||||
state.lastVideoKeyframe = pkt.IsKeyFrame
|
||||
}
|
||||
|
||||
// processAudioPacket processes an audio packet and writes samples to the broadcaster.
|
||||
@@ -1107,7 +1097,7 @@ func processAudioPacket(pkt packets.Packet, state *streamState, audioBroadcaster
|
||||
"samples_queued": state.audioSamplesSent,
|
||||
}).Debug("WebRTC audio sample queued")
|
||||
}
|
||||
audioBroadcaster.WriteSample(*state.lastAudioSample, false)
|
||||
audioBroadcaster.WriteSample(*state.lastAudioSample)
|
||||
}
|
||||
|
||||
state.lastAudioSample = &sample
|
||||
|
||||
@@ -1,18 +1,6 @@
|
||||
package webrtc
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/kerberos-io/agent/machinery/src/models"
|
||||
"github.com/kerberos-io/agent/machinery/src/packets"
|
||||
"github.com/pion/rtcp"
|
||||
pionWebRTC "github.com/pion/webrtc/v4"
|
||||
pionMedia "github.com/pion/webrtc/v4/pkg/media"
|
||||
)
|
||||
import "testing"
|
||||
|
||||
func TestBuildICEServersOmitsEmptyURLs(t *testing.T) {
|
||||
webRTC := CreateWebRTC("camera", []string{""}, []string{""}, "", "")
|
||||
@@ -38,7 +26,6 @@ func TestBuildICEServersIncludesConfiguredURLs(t *testing.T) {
|
||||
if len(iceServers) != 2 {
|
||||
t.Fatalf("buildICEServers() returned %d servers, want 2", len(iceServers))
|
||||
}
|
||||
|
||||
if got := iceServers[0].URLs[0]; got != "stun:turn-fra1.kerberos.io:3478" {
|
||||
t.Fatalf("STUN URL = %q, want trimmed URL", got)
|
||||
}
|
||||
@@ -49,138 +36,3 @@ func TestBuildICEServersIncludesConfiguredURLs(t *testing.T) {
|
||||
t.Fatal("TURN credentials were not preserved")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWebRTCConnectionRequestsStartupAndRecoveryKeyframes(t *testing.T) {
|
||||
viewer, err := pionWebRTC.NewPeerConnection(pionWebRTC.Configuration{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
if err := viewer.Close(); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
if _, err := viewer.AddTransceiverFromKind(pionWebRTC.RTPCodecTypeVideo, pionWebRTC.RTPTransceiverInit{
|
||||
Direction: pionWebRTC.RTPTransceiverDirectionRecvonly,
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tracks := make(chan *pionWebRTC.TrackRemote, 1)
|
||||
viewer.OnTrack(func(track *pionWebRTC.TrackRemote, _ *pionWebRTC.RTPReceiver) {
|
||||
tracks <- track
|
||||
})
|
||||
offer, err := viewer.CreateOffer(nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
gathered := pionWebRTC.GatheringCompletePromise(viewer)
|
||||
if err := viewer.SetLocalDescription(offer); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
select {
|
||||
case <-gathered:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("viewer ICE gathering timed out")
|
||||
}
|
||||
|
||||
requests := make(chan time.Time, 10)
|
||||
b := NewVideoBroadcaster([]packets.Stream{{Name: "H264", IsVideo: true}}, keyframeTestSource{
|
||||
request: func() error { requests <- time.Now(); return nil },
|
||||
})
|
||||
t.Cleanup(b.Close)
|
||||
const sessionKey = "unit-camera/startup-recovery"
|
||||
t.Cleanup(func() {
|
||||
globalConnectionManager.mu.RLock()
|
||||
wrapper := globalConnectionManager.peerConnections[sessionKey]
|
||||
globalConnectionManager.mu.RUnlock()
|
||||
if wrapper != nil {
|
||||
cleanupPeerConnection(sessionKey, wrapper)
|
||||
}
|
||||
})
|
||||
var signalingMu sync.Mutex
|
||||
var pending []pionWebRTC.ICECandidateInit
|
||||
signaling := &models.LiveHDSignalingCallbacks{
|
||||
SendCandidate: func(_ string, data string) error {
|
||||
var candidate pionWebRTC.ICECandidateInit
|
||||
if err := json.Unmarshal([]byte(data), &candidate); err != nil {
|
||||
return err
|
||||
}
|
||||
signalingMu.Lock()
|
||||
defer signalingMu.Unlock()
|
||||
if viewer.RemoteDescription() == nil {
|
||||
pending = append(pending, candidate)
|
||||
return nil
|
||||
}
|
||||
return viewer.AddICECandidate(candidate)
|
||||
},
|
||||
SendAnswer: func(_ string, data string) error {
|
||||
answer, err := base64.StdEncoding.DecodeString(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
signalingMu.Lock()
|
||||
defer signalingMu.Unlock()
|
||||
if err := viewer.SetRemoteDescription(pionWebRTC.SessionDescription{
|
||||
Type: pionWebRTC.SDPTypeAnswer, SDP: string(answer),
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, candidate := range pending {
|
||||
if err := viewer.AddICECandidate(candidate); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
pending = nil
|
||||
return nil
|
||||
},
|
||||
}
|
||||
InitializeWebRTCConnection(
|
||||
&models.Configuration{Config: models.Config{Key: "unit-camera"}},
|
||||
&models.Communication{}, nil, b, nil,
|
||||
models.LiveHDHandshake{
|
||||
Signaling: signaling,
|
||||
Payload: models.RequestHDStreamPayload{
|
||||
SessionID: "startup-recovery",
|
||||
SessionDescription: base64.StdEncoding.EncodeToString([]byte(viewer.LocalDescription().SDP)),
|
||||
},
|
||||
},
|
||||
)
|
||||
var firstRequest time.Time
|
||||
select {
|
||||
case firstRequest = <-requests:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("connected transport did not request a startup keyframe")
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x41, 0x80}, Duration: time.Second / 30}, false)
|
||||
select {
|
||||
case <-tracks:
|
||||
t.Fatal("viewer received dependent video before its startup IDR")
|
||||
case <-time.After(100 * time.Millisecond):
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x65, 0x88, 0x84}, Duration: time.Second / 30}, true)
|
||||
var track *pionWebRTC.TrackRemote
|
||||
select {
|
||||
case track = <-tracks:
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatal("viewer did not receive the requested startup IDR")
|
||||
}
|
||||
|
||||
for _, feedback := range []rtcp.Packet{
|
||||
&rtcp.PictureLossIndication{SenderSSRC: 42, MediaSSRC: uint32(track.SSRC())},
|
||||
&rtcp.FullIntraRequest{SenderSSRC: 42, FIR: []rtcp.FIREntry{{SSRC: uint32(track.SSRC()), SequenceNumber: 1}}},
|
||||
} {
|
||||
if err := viewer.WriteRTCP([]rtcp.Packet{feedback}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
select {
|
||||
case at := <-requests:
|
||||
if at.Sub(firstRequest) < keyframeRequestInterval-5*time.Millisecond {
|
||||
t.Fatal("real viewer feedback bypassed keyframe request throttling")
|
||||
}
|
||||
firstRequest = at
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatalf("real %T feedback did not request a recovery keyframe", feedback)
|
||||
}
|
||||
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x65, 0x88, 0x84}, Duration: time.Second / 30}, true)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,163 +0,0 @@
|
||||
package webrtc
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/pion/interceptor"
|
||||
"github.com/pion/rtcp"
|
||||
"github.com/pion/rtp"
|
||||
pionWebRTC "github.com/pion/webrtc/v4"
|
||||
pionMedia "github.com/pion/webrtc/v4/pkg/media"
|
||||
)
|
||||
|
||||
type clockTestWriter struct {
|
||||
timestamps []uint32
|
||||
}
|
||||
|
||||
func (w *clockTestWriter) WriteRTP(header *rtp.Header, payload []byte) (int, error) {
|
||||
w.timestamps = append(w.timestamps, header.Timestamp)
|
||||
return len(payload), nil
|
||||
}
|
||||
|
||||
func (*clockTestWriter) Write([]byte) (int, error) {
|
||||
return 0, errors.New("unexpected raw RTP write")
|
||||
}
|
||||
|
||||
type clockTestContext struct {
|
||||
writer *clockTestWriter
|
||||
}
|
||||
|
||||
func (clockTestContext) ID() string { return "clock-test" }
|
||||
func (clockTestContext) SSRC() pionWebRTC.SSRC { return 123 }
|
||||
func (clockTestContext) SSRCRetransmission() pionWebRTC.SSRC { return 0 }
|
||||
func (clockTestContext) SSRCForwardErrorCorrection() pionWebRTC.SSRC { return 0 }
|
||||
func (clockTestContext) RTCPReader() interceptor.RTCPReader { return nil }
|
||||
func (clockTestContext) HeaderExtensions() []pionWebRTC.RTPHeaderExtensionParameter {
|
||||
return nil
|
||||
}
|
||||
func (c clockTestContext) WriteStream() pionWebRTC.TrackLocalWriter { return c.writer }
|
||||
func (clockTestContext) CodecParameters() []pionWebRTC.RTPCodecParameters {
|
||||
return []pionWebRTC.RTPCodecParameters{{
|
||||
RTPCodecCapability: pionWebRTC.RTPCodecCapability{MimeType: pionWebRTC.MimeTypeH264, ClockRate: 90000},
|
||||
PayloadType: 96,
|
||||
}}
|
||||
}
|
||||
|
||||
func clockTestPeer(t *testing.T) (*TrackBroadcaster, *peerTrack, *clockTestWriter) {
|
||||
t.Helper()
|
||||
b, pt := testVideoBroadcaster(t)
|
||||
pt.samples = make(chan peerSample, 2)
|
||||
track, err := pionWebRTC.NewTrackLocalStaticSample(
|
||||
pionWebRTC.RTPCodecCapability{MimeType: pionWebRTC.MimeTypeH264},
|
||||
"video", "clock-test", pionWebRTC.WithRTPTimestamp(1000),
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
writer := &clockTestWriter{}
|
||||
if _, err := track.Bind(clockTestContext{writer: writer}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
pt.track = track
|
||||
b.SetPeerConnected("viewer", true)
|
||||
return b, pt, writer
|
||||
}
|
||||
|
||||
func clockVideoSample(duration time.Duration) pionMedia.Sample {
|
||||
return pionMedia.Sample{
|
||||
Data: []byte{0, 0, 0, 1, 0x65, 0x88, 0x84},
|
||||
Duration: duration,
|
||||
}
|
||||
}
|
||||
|
||||
func writeClockSample(t *testing.T, pt *peerTrack) {
|
||||
t.Helper()
|
||||
select {
|
||||
case sample := <-pt.samples:
|
||||
if err := writePeerSample(pt.track, sample); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
default:
|
||||
t.Fatal("expected queued video sample")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVideoRecoveryPreservesRTPClock(t *testing.T) {
|
||||
for _, scenario := range []string{"PLI", "FIR", "reconnect", "overflow"} {
|
||||
t.Run(scenario, func(t *testing.T) {
|
||||
b, pt, writer := clockTestPeer(t)
|
||||
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
|
||||
writeClockSample(t, pt)
|
||||
b.WriteSample(clockVideoSample(70*time.Millisecond), false)
|
||||
|
||||
switch scenario {
|
||||
case "PLI", "FIR":
|
||||
var feedback rtcp.Packet = &rtcp.PictureLossIndication{MediaSSRC: 123}
|
||||
if scenario == "FIR" {
|
||||
feedback = &rtcp.FullIntraRequest{FIR: []rtcp.FIREntry{{SSRC: 123, SequenceNumber: 1}}}
|
||||
}
|
||||
data, err := rtcp.Marshal([]rtcp.Packet{feedback})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := b.HandleRTCP("viewer", data); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
|
||||
case "reconnect":
|
||||
b.SetPeerConnected("viewer", false)
|
||||
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
|
||||
b.SetPeerConnected("viewer", true)
|
||||
case "overflow":
|
||||
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
|
||||
}
|
||||
b.WriteSample(clockVideoSample(1900*time.Millisecond), false)
|
||||
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
|
||||
writeClockSample(t, pt)
|
||||
|
||||
if len(writer.timestamps) != 2 {
|
||||
t.Fatalf("sent %d RTP packets, want only the two IDRs", len(writer.timestamps))
|
||||
}
|
||||
// The initial 40 ms frame plus 2000 ms of discarded video at 90 kHz.
|
||||
if got := writer.timestamps[1] - writer.timestamps[0]; got != 183600 {
|
||||
t.Fatalf("recovery RTP timestamp delta = %d, want 183600", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestOverflowIDRPreservesDiscardedRTPDuration(t *testing.T) {
|
||||
b, pt, writer := clockTestPeer(t)
|
||||
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
|
||||
writeClockSample(t, pt)
|
||||
b.WriteSample(clockVideoSample(70*time.Millisecond), false)
|
||||
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
|
||||
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
|
||||
writeClockSample(t, pt)
|
||||
if len(writer.timestamps) != 2 || writer.timestamps[1]-writer.timestamps[0] != 12600 {
|
||||
t.Fatalf("overflow IDR compressed the RTP clock: %v", writer.timestamps)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepeatedFeedbackPreservesAlreadyQueuedSkippedTime(t *testing.T) {
|
||||
b, pt, writer := clockTestPeer(t)
|
||||
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
|
||||
writeClockSample(t, pt)
|
||||
data, err := rtcp.Marshal([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: 123}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for range 2 {
|
||||
if err := b.HandleRTCP("viewer", data); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
b.WriteSample(clockVideoSample(time.Second), false)
|
||||
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
|
||||
}
|
||||
writeClockSample(t, pt)
|
||||
if len(writer.timestamps) != 2 || writer.timestamps[1]-writer.timestamps[0] != 187200 {
|
||||
t.Fatalf("repeated feedback lost queued skipped time: %v", writer.timestamps)
|
||||
}
|
||||
}
|
||||
@@ -24,11 +24,83 @@ See the section about [running tests](https://facebook.github.io/create-react-ap
|
||||
Builds the app for production to the `build` folder.\
|
||||
It correctly bundles React in production mode and optimizes the build for the best performance.
|
||||
|
||||
The build script then replaces `../machinery/www` with the generated assets.
|
||||
Run it in an isolated checkout or container when validating dependencies.
|
||||
|
||||
The build is minified and the filenames include the hashes.\
|
||||
Your app is ready to be deployed!
|
||||
|
||||
See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
|
||||
|
||||
## Dependency maintenance
|
||||
|
||||
Use the Node 22 image pinned in the root Dockerfile and Yarn Classic:
|
||||
|
||||
```sh
|
||||
yarn install --frozen-lockfile
|
||||
CI=true yarn test --watchAll=false --runInBand
|
||||
yarn test:dependencies
|
||||
yarn build
|
||||
```
|
||||
|
||||
Keep the targeted `underscore` resolution: `jsonpath` pins a vulnerable version.
|
||||
That resolution stays within the same major version. Axios remains on
|
||||
its maintained 0.x line; `src/api/api.test.js` checks the HTTP behavior used by
|
||||
the app without mocking Axios. Localization uses `i18next-xhr-backend`, not the
|
||||
removed, unused `i18next-http-backend` dependency.
|
||||
|
||||
Additional targeted build-time upgrades are validated against the pinned
|
||||
Node 22 / webpack 5 toolchain:
|
||||
|
||||
- [`resolve-url-loader` 5](https://github.com/bholloway/resolve-url-loader/releases/tag/5.0.0)
|
||||
upgrades PostCSS to 8, drops Node <12 / webpack <4, and removes the deprecated
|
||||
`rework` engine. CRA uses the supported PostCSS engine and unchanged `root` /
|
||||
`sourceMap` options. Dependency tests check relative SCSS asset URLs, query
|
||||
strings and fragments with source maps enabled and disabled.
|
||||
- [`serialize-javascript` 7](https://github.com/yahoo/serialize-javascript/releases/tag/v7.0.0)
|
||||
requires Node >=20, matching this UI's declared minimum. Its CommonJS serializer
|
||||
API remains compatible with CSS minimizer and Rollup worker options.
|
||||
Versions 5/6 changed sparse-array and URL serialization, neither of which these
|
||||
callers use. Tests cover both consumers' function / regular-expression
|
||||
serialization and the real Workbox Rollup minification worker; the production
|
||||
build exercises CSS minimization. The targeted resolutions use patched 7.1.4.
|
||||
- [`@svgr/webpack` 6](https://react-svgr.com/docs/migrate/) supports webpack 5 and
|
||||
the existing `file-loader` combination. CRA disables SVGO and does not use a
|
||||
custom template or call `@svgr/core`, so the documented breaking changes do
|
||||
not affect this pipeline. Tests use CRA's actual SVG rule to check asset URLs,
|
||||
React 17 rendering, viewBox preservation, titles and forwarded refs.
|
||||
- [`webpack-dev-middleware` 7](https://github.com/webpack/webpack-dev-middleware/releases/tag/v7.0.0)
|
||||
raises the Node minimum and upgrades its internal memory filesystem; version 6
|
||||
raised the webpack minimum to 5. Both requirements match this toolchain, and
|
||||
webpack-dev-server remains on CRA's 4.x line. Tests exercise real server
|
||||
compilation, in-memory asset serving, missing assets and invalidation with
|
||||
patched middleware 7.4.6. No build artifacts are written by this test.
|
||||
|
||||
Refreshing the lockfile does not resolve every legacy-toolchain advisory.
|
||||
Create React App 5, `@kerberos-io/ui`'s SVG tooling, and their transitive
|
||||
dependencies still require upstream upgrades or explicit, tested migrations.
|
||||
Do not force incompatible transitive major versions just to clear a scan.
|
||||
|
||||
The obsolete `svg-react-loader` dependency declared by `@kerberos-io/ui` is
|
||||
replaced with the maintained `@svgr/webpack` 8.1.0 through a Yarn package alias.
|
||||
This removes its `css -> source-map-resolve -> decode-uri-component` chain;
|
||||
it does not force an incompatible ESM version of the decoder into a CommonJS
|
||||
caller. The shared UI ships precompiled SVG components and does not invoke that
|
||||
loader. CRA's active SVG rule remains on the separately tested SVGR 6 path.
|
||||
SVGR 8.1.0 is also pinned explicitly as a development dependency, so dependency
|
||||
scanners inventory and check its actual package identity even if their Yarn
|
||||
alias parser reports an additional `svg-react-loader@8.1.0` entry. Tests verify
|
||||
that both names resolve to identical package metadata; the alias is not used
|
||||
to conceal an unscanned replacement.
|
||||
|
||||
This is a scoped consumer migration, **not** a general drop-in implementation of
|
||||
the old loader's `raw`, `filters`, `propsMap` or other query options. Dependency
|
||||
tests guard against shared UI code starting to call the legacy API, resolve the
|
||||
alias from the shared package, and compile/render its maintained replacement
|
||||
with React 17, titles, forwarded refs, viewBox and caller props. Rendering is
|
||||
compared to CRA's actual SVG pipeline. Recheck these assumptions on shared UI
|
||||
upgrades; use SVGR's supported options for any new loader calls.
|
||||
|
||||
### `yarn eject`
|
||||
|
||||
**Note: this is a one-way operation. Once you `eject`, you can’t go back!**
|
||||
|
||||
+16
-2
@@ -9,7 +9,7 @@
|
||||
"@testing-library/jest-dom": "^5.16.5",
|
||||
"@testing-library/react": "^11.2.7",
|
||||
"@testing-library/user-event": "^12.8.3",
|
||||
"axios": "^0.21.4",
|
||||
"axios": "^0.35.0",
|
||||
"classnames": "^2.3.1",
|
||||
"connected-react-router": "^6.9.3",
|
||||
"eslint-config-prettier": "8.5.*",
|
||||
@@ -18,7 +18,6 @@
|
||||
"history": "4.10.1",
|
||||
"i18next": "^21.9.1",
|
||||
"i18next-browser-languagedetector": "^6.1.5",
|
||||
"i18next-http-backend": "^1.4.1",
|
||||
"i18next-xhr-backend": "^3.2.2",
|
||||
"md5": "^2.3.0",
|
||||
"prettier": "^2.7.1",
|
||||
@@ -41,6 +40,19 @@
|
||||
"vott-ct": "^2.3.3",
|
||||
"web-vitals": "^0.2.4"
|
||||
},
|
||||
"resolutions": {
|
||||
"**/svg-react-loader": "npm:@svgr/webpack@8.1.0",
|
||||
"**/jsonpath/underscore": "^1.13.8",
|
||||
"**/resolve-url-loader": "^5.0.0",
|
||||
"**/css-minimizer-webpack-plugin/serialize-javascript": "^7.1.4",
|
||||
"**/rollup-plugin-terser/serialize-javascript": "^7.1.4",
|
||||
"**/react-scripts/@svgr/webpack": "^6.5.1",
|
||||
"**/@kerberos-io/ui/@svgr/webpack": "^6.5.1",
|
||||
"**/webpack-dev-server/webpack-dev-middleware": "^7.4.6"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=20"
|
||||
},
|
||||
"browser": {
|
||||
"crypto": false
|
||||
},
|
||||
@@ -48,6 +60,7 @@
|
||||
"start": "DISABLE_ESLINT_PLUGIN=true react-scripts start",
|
||||
"build": "DISABLE_ESLINT_PLUGIN=true GENERATE_SOURCEMAP=false REACT_APP_ENVIRONMENT=production react-scripts build && rm -rf ../machinery/www && mv build ../machinery/www",
|
||||
"test": "DISABLE_ESLINT_PLUGIN=true react-scripts test",
|
||||
"test:dependencies": "node --test scripts/dependency-compatibility.test.cjs",
|
||||
"eject": "react-scripts eject",
|
||||
"lint": "eslint --debug 'src/**/*.{js,jsx,ts,tsx}'",
|
||||
"format": "prettier --write \"**/*.{js,jsx,json,md}\""
|
||||
@@ -65,6 +78,7 @@
|
||||
]
|
||||
},
|
||||
"devDependencies": {
|
||||
"@svgr/webpack": "8.1.0",
|
||||
"eslint": "^7.32.0",
|
||||
"eslint-config-airbnb": "^18.2.1",
|
||||
"eslint-plugin-import": "^2.26.0",
|
||||
|
||||
@@ -0,0 +1,261 @@
|
||||
const assert = require('node:assert/strict');
|
||||
const path = require('node:path');
|
||||
const fs = require('node:fs');
|
||||
const { createRequire } = require('node:module');
|
||||
const { test } = require('node:test');
|
||||
const vm = require('node:vm');
|
||||
|
||||
const requireFromCRA = createRequire(
|
||||
require.resolve('react-scripts/package.json')
|
||||
);
|
||||
const resolveUrlLoader = requireFromCRA('resolve-url-loader');
|
||||
const { SourceMapGenerator } = createRequire(
|
||||
requireFromCRA.resolve('resolve-url-loader')
|
||||
)('source-map');
|
||||
|
||||
for (const sourceMap of [false, true]) {
|
||||
test(`SCSS URL resolution preserves nested assets and query strings (sourceMap=${sourceMap})`, async () => {
|
||||
const root = path.resolve(__dirname, '../src');
|
||||
const content =
|
||||
'.fixture { background: url("../../header-minimal-logo-36x36.svg?theme=dark#icon"); }';
|
||||
const map = new SourceMapGenerator({ file: path.join(root, 'App.scss') });
|
||||
map.addMapping({
|
||||
generated: { line: 1, column: 0 },
|
||||
original: { line: 1, column: 0 },
|
||||
source: path.join(root, 'components/LanguageSelect/LanguageSelect.scss'),
|
||||
});
|
||||
map.setSourceContent(
|
||||
path.join(root, 'components/LanguageSelect/LanguageSelect.scss'),
|
||||
content
|
||||
);
|
||||
|
||||
const result = await new Promise((resolve, reject) => {
|
||||
resolveUrlLoader.call(
|
||||
{
|
||||
resourcePath: path.join(root, 'App.scss'),
|
||||
context: root,
|
||||
rootContext: path.resolve(__dirname, '..'),
|
||||
fs,
|
||||
sourceMap,
|
||||
query: { sourceMap, root },
|
||||
getOptions() {
|
||||
return this.query;
|
||||
},
|
||||
cacheable() {},
|
||||
emitWarning: reject,
|
||||
async() {
|
||||
return (error, css, outputMap) => {
|
||||
if (error) reject(error);
|
||||
else resolve({ css, outputMap });
|
||||
};
|
||||
},
|
||||
},
|
||||
content,
|
||||
map.toJSON()
|
||||
);
|
||||
});
|
||||
|
||||
assert.match(
|
||||
result.css,
|
||||
/url\("\.\/header-minimal-logo-36x36\.svg\?theme=dark#icon"\)/
|
||||
);
|
||||
assert.equal(Boolean(result.outputMap), sourceMap);
|
||||
});
|
||||
}
|
||||
|
||||
for (const parent of ['css-minimizer-webpack-plugin', 'rollup-plugin-terser']) {
|
||||
test(`${parent} serializes worker options with functions and regular expressions`, () => {
|
||||
const requireFromParent = createRequire(requireFromCRA.resolve(parent));
|
||||
const serialize = requireFromParent('serialize-javascript');
|
||||
const version = requireFromParent(
|
||||
'serialize-javascript/package.json'
|
||||
).version;
|
||||
assert.match(version, /^7\./);
|
||||
|
||||
const options = {
|
||||
comments: /^keep/,
|
||||
minify: (input) => input.trim(),
|
||||
nested: { passes: 2 },
|
||||
};
|
||||
const restored = vm.runInNewContext(`(${serialize(options)})`);
|
||||
|
||||
assert.equal(restored.comments.test('keep license'), true);
|
||||
assert.equal(restored.comments.test('discard comment'), false);
|
||||
assert.equal(restored.minify(' body '), 'body');
|
||||
assert.equal(restored.nested.passes, 2);
|
||||
});
|
||||
}
|
||||
|
||||
test('Workbox Rollup minification passes serialized options through its real worker', async () => {
|
||||
const { rollup } = requireFromCRA('rollup');
|
||||
const { terser } = requireFromCRA('rollup-plugin-terser');
|
||||
const bundle = await rollup({
|
||||
input: 'compatibility-entry',
|
||||
plugins: [
|
||||
{
|
||||
name: 'compatibility-fixture',
|
||||
resolveId: (id) => (id === 'compatibility-entry' ? id : null),
|
||||
load: () =>
|
||||
'/*! keep license */ export const double = (value) => value * 2;',
|
||||
},
|
||||
terser({
|
||||
numWorkers: 1,
|
||||
mangle: false,
|
||||
compress: { passes: 2 },
|
||||
format: { comments: /keep/ },
|
||||
}),
|
||||
],
|
||||
});
|
||||
|
||||
try {
|
||||
const { output } = await bundle.generate({
|
||||
format: 'cjs',
|
||||
sourcemap: true,
|
||||
});
|
||||
const exports = {};
|
||||
vm.runInNewContext(output[0].code, { exports });
|
||||
|
||||
assert.equal(exports.double(21), 42);
|
||||
assert.match(output[0].code, /2\*value/);
|
||||
assert.ok(output[0].map);
|
||||
} finally {
|
||||
await bundle.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('shared UI ships precompiled SVGs without legacy loader calls', () => {
|
||||
const packagePath = require.resolve('@kerberos-io/ui/package.json');
|
||||
const requireFromUI = createRequire(packagePath);
|
||||
const replacement = requireFromUI('svg-react-loader/package.json');
|
||||
assert.equal(replacement.name, '@svgr/webpack');
|
||||
assert.equal(replacement.version, '8.1.0');
|
||||
assert.deepEqual(replacement, require('@svgr/webpack/package.json'));
|
||||
assert.equal(requireFromCRA('@svgr/webpack/package.json').version, '6.5.1');
|
||||
|
||||
const lib = path.join(path.dirname(packagePath), 'lib');
|
||||
const files = fs
|
||||
.readdirSync(lib, { recursive: true })
|
||||
.filter((file) => /\.[cm]?js$/.test(file));
|
||||
assert.ok(files.length > 0);
|
||||
for (const file of files) {
|
||||
assert.doesNotMatch(
|
||||
fs.readFileSync(path.join(lib, file), 'utf8'),
|
||||
/svg-react-loader/,
|
||||
`Shared UI now uses the legacy loader API in ${file}`
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('CRA and replacement SVG loaders preserve rendering through webpack-dev-server', async () => {
|
||||
process.env.NODE_ENV = 'production';
|
||||
const webpack = requireFromCRA('webpack');
|
||||
const DevServer = requireFromCRA('webpack-dev-server');
|
||||
const React = require('react');
|
||||
const { renderToStaticMarkup } = require('react-dom/server');
|
||||
const craConfig = requireFromCRA('./config/webpack.config.js')('production');
|
||||
const svgRule = craConfig.module.rules
|
||||
.find((rule) => rule.oneOf)
|
||||
.oneOf.find(
|
||||
(rule) => rule.test instanceof RegExp && rule.test.test('icon.svg')
|
||||
);
|
||||
assert.ok(svgRule);
|
||||
|
||||
const logoPath = path.resolve(
|
||||
__dirname,
|
||||
'../src/header-minimal-logo-36x36.svg'
|
||||
);
|
||||
const requireFromUI = createRequire(
|
||||
require.resolve('@kerberos-io/ui/package.json')
|
||||
);
|
||||
const replacementRequest = `!!${requireFromUI.resolve(
|
||||
'svg-react-loader'
|
||||
)}?${JSON.stringify({
|
||||
svgo: false,
|
||||
titleProp: true,
|
||||
ref: true,
|
||||
})}!${logoPath}`;
|
||||
const entry = `import url, { ReactComponent as Logo } from ${JSON.stringify(
|
||||
logoPath
|
||||
)}; import ReplacementLogo from ${JSON.stringify(
|
||||
replacementRequest
|
||||
)}; export { url, Logo, ReplacementLogo };`;
|
||||
const compiler = webpack({
|
||||
mode: 'development',
|
||||
target: 'node',
|
||||
entry: `data:text/javascript,${encodeURIComponent(entry)}`,
|
||||
output: {
|
||||
path: path.resolve(__dirname, '.dependency-webpack-output'),
|
||||
filename: 'compatibility.js',
|
||||
publicPath: '/compiled/',
|
||||
library: { type: 'commonjs2' },
|
||||
},
|
||||
externals: { react: 'commonjs react' },
|
||||
module: { rules: [{ ...svgRule, issuer: undefined }] },
|
||||
infrastructureLogging: { level: 'error' },
|
||||
stats: 'errors-only',
|
||||
});
|
||||
const server = new DevServer(
|
||||
{
|
||||
host: '127.0.0.1',
|
||||
port: 0,
|
||||
static: false,
|
||||
hot: false,
|
||||
client: false,
|
||||
liveReload: false,
|
||||
webSocketServer: false,
|
||||
setupExitSignals: false,
|
||||
devMiddleware: { publicPath: '/compiled/', stats: 'errors-only' },
|
||||
},
|
||||
compiler
|
||||
);
|
||||
|
||||
try {
|
||||
await server.start();
|
||||
const stats = await new Promise((resolve) =>
|
||||
server.middleware.waitUntilValid(resolve)
|
||||
);
|
||||
assert.equal(
|
||||
stats.hasErrors(),
|
||||
false,
|
||||
stats.toString({ all: false, errors: true })
|
||||
);
|
||||
|
||||
const baseURL = `http://127.0.0.1:${
|
||||
server.server.address().port
|
||||
}/compiled/`;
|
||||
const response = await fetch(`${baseURL}compatibility.js`);
|
||||
assert.equal(response.status, 200);
|
||||
const module = { exports: {} };
|
||||
vm.runInNewContext(await response.text(), {
|
||||
module,
|
||||
exports: module.exports,
|
||||
require,
|
||||
});
|
||||
const { Logo, ReplacementLogo, url } = module.exports;
|
||||
assert.equal(Logo.$$typeof, Symbol.for('react.forward_ref'));
|
||||
assert.equal(ReplacementLogo.$$typeof, Symbol.for('react.forward_ref'));
|
||||
const props = {
|
||||
title: 'Camera icon',
|
||||
titleId: 'camera-title',
|
||||
className: 'camera-icon',
|
||||
width: 48,
|
||||
ref: React.createRef(),
|
||||
};
|
||||
const markup = renderToStaticMarkup(React.createElement(Logo, props));
|
||||
assert.equal(
|
||||
renderToStaticMarkup(React.createElement(ReplacementLogo, props)),
|
||||
markup
|
||||
);
|
||||
assert.match(markup, /<svg/);
|
||||
assert.match(markup, /<title id="camera-title">Camera icon<\/title>/);
|
||||
assert.match(markup, /viewBox=/);
|
||||
assert.match(markup, /<path/);
|
||||
assert.match(url, /^\/compiled\/static\/media\/.*\.svg$/);
|
||||
assert.equal((await fetch(new URL(url, baseURL))).status, 200);
|
||||
assert.equal((await fetch(`${baseURL}missing.js`)).status, 404);
|
||||
await new Promise((resolve) => server.middleware.invalidate(resolve));
|
||||
assert.equal((await fetch(`${baseURL}compatibility.js`)).status, 200);
|
||||
} finally {
|
||||
await server.stop();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,65 @@
|
||||
/* eslint-env jest */
|
||||
import API from './api';
|
||||
import config from '../config';
|
||||
|
||||
jest.mock('../config', () => ({
|
||||
API_URL: 'http://localhost/api',
|
||||
}));
|
||||
|
||||
describe('HTTP client compatibility', () => {
|
||||
let originalAdapter;
|
||||
let adapter;
|
||||
|
||||
beforeEach(() => {
|
||||
originalAdapter = API.defaults.adapter;
|
||||
adapter = jest.fn((request) => {
|
||||
const response = {
|
||||
config: request,
|
||||
status: 200,
|
||||
statusText: 'OK',
|
||||
headers: {},
|
||||
data: '{"ok":true}',
|
||||
};
|
||||
return Promise.resolve(response);
|
||||
});
|
||||
API.defaults.adapter = adapter;
|
||||
localStorage.setItem('token', 'test-token');
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
API.defaults.adapter = originalAdapter;
|
||||
localStorage.clear();
|
||||
});
|
||||
|
||||
it('preserves API URLs, bearer authentication, timeouts and JSON responses', async () => {
|
||||
const response = await API.get('dashboard', { timeout: 15000 });
|
||||
const request = adapter.mock.calls[0][0];
|
||||
|
||||
expect(request.baseURL).toBe(config.API_URL);
|
||||
expect(request.url).toBe('dashboard');
|
||||
expect(request.method).toBe('get');
|
||||
expect(request.headers.Authorization).toBe('Bearer test-token');
|
||||
expect(request.timeout).toBe(15000);
|
||||
expect(response.data).toEqual({ ok: true });
|
||||
});
|
||||
|
||||
it('serializes saved configuration as JSON and reads refreshed credentials', async () => {
|
||||
localStorage.setItem('token', 'refreshed-token');
|
||||
const settings = { capture: { ipcamera: { rtsp: 'rtsp://camera/live' } } };
|
||||
|
||||
await API.post('config', settings);
|
||||
const request = adapter.mock.calls[0][0];
|
||||
|
||||
expect(request.method).toBe('post');
|
||||
expect(request.headers.Authorization).toBe('Bearer refreshed-token');
|
||||
expect(request.headers['Content-Type']).toMatch(/^application\/json/);
|
||||
expect(JSON.parse(request.data)).toEqual(settings);
|
||||
});
|
||||
|
||||
it('preserves rejected requests for API error handlers', async () => {
|
||||
const error = new Error('Request timed out');
|
||||
adapter.mockRejectedValueOnce(error);
|
||||
|
||||
await expect(API.get('dashboard', { timeout: 15000 })).rejects.toBe(error);
|
||||
});
|
||||
});
|
||||
+4845
-3765
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user