|
|
@@ -0,0 +1,348 @@
|
|
|
+"""Reproduce the approved model assessment without changing production files.
|
|
|
+
|
|
|
+Uses the existing SSH alias for read-only baseline inspection and disposable,
|
|
|
+resource-limited OSRM containers. Synthetic XML and candidate Lua are generated
|
|
|
+only under an owned /tmp directory. No business database or credentials are read.
|
|
|
+"""
|
|
|
+import hashlib
|
|
|
+import json
|
|
|
+from pathlib import Path
|
|
|
+import subprocess
|
|
|
+import sys
|
|
|
+import urllib.request
|
|
|
+
|
|
|
+VALHALLA_SHA = "34639a33510eb0764da77650e91f6efbb70e8daa"
|
|
|
+MAP_REPO = Path("D:/QtwCode/foodie/Foodie_HCM_Map")
|
|
|
+OUTPUT = Path(__file__).with_name("model-probe-results.json")
|
|
|
+
|
|
|
+
|
|
|
+def remote_probe():
|
|
|
+ """This function executes on the SSH host, with the standard library only."""
|
|
|
+ import datetime
|
|
|
+ import math
|
|
|
+ import tempfile
|
|
|
+ import time
|
|
|
+ import urllib.error
|
|
|
+ import urllib.parse
|
|
|
+ import xml.etree.ElementTree as ET
|
|
|
+
|
|
|
+ image = "ghcr.io/project-osrm/osrm-backend:v5.27.1"
|
|
|
+ release = Path("/opt/foodie-map-tw-20260909")
|
|
|
+ production = ["foodie-map-tw-20260909-api-1", "foodie-map-tw-20260909-osrm-1",
|
|
|
+ "foodie-map-tw-20260909-osrm-motorcycle-1"]
|
|
|
+
|
|
|
+ def command(args):
|
|
|
+ completed = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=90)
|
|
|
+ if completed.returncode:
|
|
|
+ raise RuntimeError("Command failed: " + " ".join(args) + "\n" + completed.stdout.decode(errors="replace")[-4000:])
|
|
|
+ return completed.stdout
|
|
|
+
|
|
|
+ def fingerprints():
|
|
|
+ files = ["map_api/settings.py", "map_api/routing.py", "docker/osrm/profiles/motorcycle.lua"]
|
|
|
+ hashes = {p: hashlib.sha256((release / p).read_bytes()).hexdigest() for p in files}
|
|
|
+ for p in ("settings.py", "routing.py"):
|
|
|
+ data = command(["docker", "exec", production[0], "cat", "/app/" + p])
|
|
|
+ hashes["container:/app/" + p] = hashlib.sha256(data).hexdigest()
|
|
|
+ hashes["container:car.lua"] = hashlib.sha256(command(
|
|
|
+ ["docker", "exec", production[2], "cat", "/opt/car.lua"])).hexdigest()
|
|
|
+ hashes["built_profile"] = command(["docker", "exec", production[2], "cat",
|
|
|
+ "/data/profile.sha256"]).decode().strip()
|
|
|
+ hashes["pbf"] = command(["docker", "exec", production[2], "cat",
|
|
|
+ "/data/build.sha256"]).decode().strip()
|
|
|
+ return hashes
|
|
|
+
|
|
|
+ def read_url(url):
|
|
|
+ with urllib.request.urlopen(url, timeout=8) as response:
|
|
|
+ return json.load(response)
|
|
|
+
|
|
|
+ result = {"timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
|
|
|
+ "image": image, "release": str(release), "before": fingerprints(),
|
|
|
+ "cases": [], "production_probes": {}, "errors": []}
|
|
|
+ baseline = (release / "docker/osrm/profiles/motorcycle.lua").read_text()
|
|
|
+ car_lua = command(["docker", "exec", production[2], "cat", "/opt/car.lua"])
|
|
|
+ result["combined_profile_matches_graph"] = hashlib.sha256(
|
|
|
+ car_lua + baseline.encode()).hexdigest() == result["before"]["built_profile"]
|
|
|
+ for name in ("config", "health/ready"):
|
|
|
+ result["production_probes"][name] = read_url("http://127.0.0.1:8081/api/" + name)
|
|
|
+ points = "pickup_lat=25.0330&pickup_lng=121.5654&drop_lat=25.0375&drop_lng=121.5637"
|
|
|
+ for profile in ("car", "motorcycle"):
|
|
|
+ for endpoint, params in (("route", points),
|
|
|
+ ("route/multi", "coords=25.0330,121.5654;25.0375,121.5637")):
|
|
|
+ route = read_url("http://127.0.0.1:8081/api/" + endpoint + "?" + params + "&profile=" + profile)
|
|
|
+ result["production_probes"][endpoint + ":" + profile] = {
|
|
|
+ k: route.get(k) for k in ("profile", "distance_meters", "duration_seconds", "traffic_aware")}
|
|
|
+
|
|
|
+ # Probe chosen by this assessment: keep access restrictions; penalize gravel
|
|
|
+ # through rate (not speed), and add a signal weight (not duration). Neither
|
|
|
+ # number is a copied Valhalla constant or an approved production calibration.
|
|
|
+ candidate = baseline.replace(" car.process_way(profile, proxy, result, relations)", """
|
|
|
+ car.process_way(profile, proxy, result, relations)
|
|
|
+ if way:get_value_by_key('surface') == 'gravel' then
|
|
|
+ if result.forward_rate and result.forward_rate > 0 then
|
|
|
+ result.forward_rate = result.forward_rate * 0.2
|
|
|
+ end
|
|
|
+ if result.backward_rate and result.backward_rate > 0 then
|
|
|
+ result.backward_rate = result.backward_rate * 0.2
|
|
|
+ end
|
|
|
+ end""").replace("return {setup=setup, process_way=process_way, process_node=car.process_node, process_turn=car.process_turn}", """
|
|
|
+local function process_turn(profile, turn)
|
|
|
+ car.process_turn(profile, turn)
|
|
|
+ if turn.has_traffic_light then turn.weight = turn.weight + 8 end
|
|
|
+ if math.abs(turn.angle) > 60 then turn.weight = turn.weight + 3 end
|
|
|
+end
|
|
|
+return {setup=setup, process_way=process_way, process_node=car.process_node, process_turn=process_turn}
|
|
|
+""")
|
|
|
+ if candidate == baseline or "turn.weight = turn.weight + 8" not in candidate:
|
|
|
+ raise RuntimeError("Unexpected baseline shape; no automatic production adaptation.")
|
|
|
+ result["candidate_sha256"] = hashlib.sha256(candidate.encode()).hexdigest()
|
|
|
+
|
|
|
+ root = ET.Element("osm", version="0.6", generator="foodie-isolated-model-assessment")
|
|
|
+ counter = 0
|
|
|
+ samples = {}
|
|
|
+
|
|
|
+ def node(lat, lon, tags=None):
|
|
|
+ nonlocal counter
|
|
|
+ counter += 1
|
|
|
+ element = ET.SubElement(root, "node", id=str(counter), lat=str(lat), lon=str(lon), version="1")
|
|
|
+ for key, value in (tags or {}).items():
|
|
|
+ ET.SubElement(element, "tag", k=key, v=value)
|
|
|
+ return counter
|
|
|
+
|
|
|
+ def way(ids, tags):
|
|
|
+ nonlocal counter
|
|
|
+ counter += 1
|
|
|
+ element = ET.SubElement(root, "way", id=str(counter), version="1")
|
|
|
+ for identifier in ids:
|
|
|
+ ET.SubElement(element, "nd", ref=str(identifier))
|
|
|
+ for key, value in tags.items():
|
|
|
+ ET.SubElement(element, "tag", k=key, v=value)
|
|
|
+ return counter
|
|
|
+
|
|
|
+ # Independent diamonds ensure a prohibited short road has a real legal
|
|
|
+ # detour. Inputs use exact shared junctions, avoiding arbitrary snap choices.
|
|
|
+ def diamond(name, tags, width=0.004, signal=False, detour=True):
|
|
|
+ lat, lon = 25.1 + len(samples) * 0.01, 121.5
|
|
|
+ a, b = node(lat, lon), node(lat + 0.002, lon)
|
|
|
+ mid = node(lat + 0.001, lon, {"highway": "traffic_signals"} if signal else {})
|
|
|
+ way([a, mid, b], {"highway": "residential", "name": name, **tags})
|
|
|
+ if detour:
|
|
|
+ c, d = node(lat, lon + width), node(lat + 0.002, lon + width)
|
|
|
+ way([a, c, d, b], {"highway": "residential", "name": name + "_detour"})
|
|
|
+ if signal:
|
|
|
+ branch = node(lat + 0.001, lon - 0.0003)
|
|
|
+ way([mid, branch], {"highway": "residential", "name": "signal_branch"})
|
|
|
+ samples[name] = [(lon, lat), (lon, lat + 0.002)]
|
|
|
+
|
|
|
+ diamond("motorcycle_no", {"motorcycle": "no"})
|
|
|
+ diamond("motorcar_no", {"motorcar": "no", "motorcycle": "yes"})
|
|
|
+ for road in ("motorway", "motorway_link", "trunk"):
|
|
|
+ diamond(road, {"highway": road})
|
|
|
+ diamond("trunk_permitted", {"highway": "trunk", "motorcycle": "yes"})
|
|
|
+ diamond("motorroad", {"motorroad": "yes"})
|
|
|
+ diamond("motorroad_permitted", {"motorroad": "yes", "motorcycle": "yes"})
|
|
|
+ diamond("oneway", {"oneway": "yes"})
|
|
|
+ diamond("oneway_override", {"oneway": "yes", "oneway:motorcycle": "no"})
|
|
|
+ diamond("speed_override", {"maxspeed:forward": "90", "maxspeed:motorcycle": "20"}, detour=False)
|
|
|
+ diamond("gravel_choice", {"highway": "primary", "surface": "gravel"}, width=0.001)
|
|
|
+ diamond("gravel_forced", {"highway": "primary", "surface": "gravel"}, detour=False)
|
|
|
+ diamond("signals", {}, signal=True, detour=False)
|
|
|
+ diamond("conditional_access", {"motorcycle:conditional": "no @ (00:00-24:00)"})
|
|
|
+
|
|
|
+ # Turn relation distinguishes real path exclusion from simply assigning a
|
|
|
+ # higher turn penalty. No two-stage-turn claim is made by this fixture.
|
|
|
+ def turn_case(name, restriction_key):
|
|
|
+ nonlocal counter
|
|
|
+ lat, lon = 25.1 + len(samples) * 0.01, 121.5
|
|
|
+ a, via, b = node(lat, lon), node(lat + 0.001, lon), node(lat + 0.001, lon + 0.001)
|
|
|
+ c, d = node(lat + 0.003, lon), node(lat + 0.003, lon + 0.001)
|
|
|
+ from_way = way([a, via], {"highway": "residential"})
|
|
|
+ to_way = way([via, b], {"highway": "residential"})
|
|
|
+ way([via, c, d, b], {"highway": "residential"})
|
|
|
+ if restriction_key:
|
|
|
+ counter += 1
|
|
|
+ relation = ET.SubElement(root, "relation", id=str(counter), version="1")
|
|
|
+ for kind, ref, role in (("way", from_way, "from"), ("node", via, "via"), ("way", to_way, "to")):
|
|
|
+ ET.SubElement(relation, "member", type=kind, ref=str(ref), role=role)
|
|
|
+ ET.SubElement(relation, "tag", k="type", v="restriction")
|
|
|
+ ET.SubElement(relation, "tag", k=restriction_key, v="no_right_turn")
|
|
|
+ samples[name] = [(lon, lat + 0.0001), (lon + 0.0009, lat + 0.001)]
|
|
|
+
|
|
|
+ turn_case("motorcycle_turn", "restriction:motorcycle")
|
|
|
+ turn_case("generic_turn", "restriction")
|
|
|
+ turn_case("unrestricted_turn", None)
|
|
|
+ # libosmium expects ordered entity types even though generated scenarios
|
|
|
+ # were appended independently. Keep nodes before ways before relations.
|
|
|
+ entities = sorted(list(root), key=lambda e: ({"node": 0, "way": 1, "relation": 2}[e.tag], int(e.attrib["id"])))
|
|
|
+ root[:] = entities
|
|
|
+ fixture = ET.tostring(root, encoding="utf-8", xml_declaration=True)
|
|
|
+ samples["offroad"] = [samples["motorcycle_no"][0], (121.7, 25.7)]
|
|
|
+ samples["disconnected"] = [samples["motorcycle_no"][0], samples["trunk_permitted"][1]]
|
|
|
+ result["fixture_sha256"] = hashlib.sha256(fixture).hexdigest()
|
|
|
+ containers = []
|
|
|
+ urls = {}
|
|
|
+
|
|
|
+ def progress(message):
|
|
|
+ print(message, file=sys.stderr, flush=True)
|
|
|
+
|
|
|
+ def route(profile, case, reverse=False):
|
|
|
+ coords = samples[case][::-1] if reverse else samples[case]
|
|
|
+ coordinates = ";".join(f"{lon},{lat}" for lon, lat in coords)
|
|
|
+ url = urls[profile] + "/route/v1/driving/" + coordinates + "?overview=full&geometries=geojson&radiuses=10;10"
|
|
|
+ try:
|
|
|
+ data = read_url(url)
|
|
|
+ except urllib.error.HTTPError as error:
|
|
|
+ data = json.load(error)
|
|
|
+ data["test_profile"] = profile
|
|
|
+ return data
|
|
|
+
|
|
|
+ def check(name, condition, observations, kind="assertion"):
|
|
|
+ row = {"name": name, "kind": kind, "passed": bool(condition), "observations": observations}
|
|
|
+ result["cases"].append(row)
|
|
|
+ progress(f"{name}: {'PASS' if condition else 'FAIL'}")
|
|
|
+
|
|
|
+ def metric(data):
|
|
|
+ if data.get("code") != "Ok":
|
|
|
+ return {"code": data.get("code")}
|
|
|
+ return {k: data["routes"][0][k] for k in ("distance", "duration", "weight")}
|
|
|
+
|
|
|
+ def distance(data):
|
|
|
+ return data["routes"][0]["distance"] if data.get("code") == "Ok" else math.inf
|
|
|
+
|
|
|
+ try:
|
|
|
+ with tempfile.TemporaryDirectory(prefix="foodie-model-eval-", dir="/tmp") as temp:
|
|
|
+ workspace = Path(temp)
|
|
|
+ result["temporary_workspace"] = str(workspace)
|
|
|
+ for profile, lua in (("car", None), ("baseline", baseline), ("candidate", candidate)):
|
|
|
+ folder = workspace / profile
|
|
|
+ folder.mkdir()
|
|
|
+ (folder / "fixture.osm").write_bytes(fixture)
|
|
|
+ if lua:
|
|
|
+ (folder / "model.lua").write_text(lua)
|
|
|
+ profile_path = "/data/model.lua" if lua else "/opt/car.lua"
|
|
|
+ base_args = ["docker", "run", "--rm", "--cpus=0.5", "--memory=256m",
|
|
|
+ "-v", f"{folder}:/data", "--entrypoint", "sh", image]
|
|
|
+ progress("Building isolated " + profile)
|
|
|
+ build = "osrm-extract --threads 1 -p " + profile_path + " /data/fixture.osm && osrm-partition --threads 1 /data/fixture.osrm && osrm-customize --threads 1 /data/fixture.osrm"
|
|
|
+ command(base_args[:3] + ["--network", "none"] + base_args[3:] + ["-c", build])
|
|
|
+ identifier = command(["docker", "run", "-d", "--rm", "--cpus=0.5", "--memory=256m",
|
|
|
+ "-p", "127.0.0.1::5000", "-v", f"{folder}:/data:ro", image,
|
|
|
+ "osrm-routed", "--algorithm", "mld", "--threads", "1", "/data/fixture.osrm"]).decode().strip()
|
|
|
+ containers.append(identifier)
|
|
|
+ info = json.loads(command(["docker", "inspect", identifier]))[0]
|
|
|
+ port = info["NetworkSettings"]["Ports"]["5000/tcp"][0]["HostPort"]
|
|
|
+ urls[profile] = "http://127.0.0.1:" + port
|
|
|
+ for _ in range(30):
|
|
|
+ try:
|
|
|
+ read_url(urls[profile] + "/nearest/v1/driving/121.5,25.1")
|
|
|
+ break
|
|
|
+ except (urllib.error.URLError, TimeoutError):
|
|
|
+ time.sleep(0.2)
|
|
|
+ else:
|
|
|
+ raise RuntimeError("Isolated engine did not start")
|
|
|
+
|
|
|
+ for case, blocked in (("motorcycle_no", True), ("motorcar_no", False),
|
|
|
+ ("motorway", True), ("motorway_link", True), ("trunk", True),
|
|
|
+ ("trunk_permitted", False), ("motorroad", True),
|
|
|
+ ("motorroad_permitted", False)):
|
|
|
+ for profile in ("baseline", "candidate"):
|
|
|
+ data = route(profile, case)
|
|
|
+ ok = data.get("code") == "Ok" and (distance(data) > 700 if blocked else distance(data) < 300)
|
|
|
+ check(profile + ":" + case, ok, metric(data))
|
|
|
+ car, moto = route("car", "motorcycle_no"), route("baseline", "motorcycle_no")
|
|
|
+ check("car_vs_motorcycle_access", distance(car) < 300 < distance(moto),
|
|
|
+ {"car": metric(car), "motorcycle": metric(moto)})
|
|
|
+ for profile in ("baseline", "candidate"):
|
|
|
+ forward, backward = route(profile, "oneway"), route(profile, "oneway", True)
|
|
|
+ check(profile + ":oneway", distance(forward) < 300 and distance(backward) > 700,
|
|
|
+ {"forward": metric(forward), "reverse": metric(backward)})
|
|
|
+ override = route(profile, "oneway_override", True)
|
|
|
+ check(profile + ":oneway_motorcycle_override", distance(override) < 300, metric(override))
|
|
|
+ for turn in ("motorcycle_turn", "generic_turn"):
|
|
|
+ data = route(profile, turn)
|
|
|
+ check(profile + ":" + turn, distance(data) > 500 and data.get("code") == "Ok", metric(data))
|
|
|
+ speed_car, speed_moto = route("car", "speed_override"), route("baseline", "speed_override")
|
|
|
+ check("motorcycle_speed_limit", metric(speed_moto).get("duration", 0) > metric(speed_car).get("duration", 0),
|
|
|
+ {"car": metric(speed_car), "motorcycle": metric(speed_moto)})
|
|
|
+ for case in ("gravel_forced", "signals", "unrestricted_turn"):
|
|
|
+ base, proposed = route("baseline", case), route("candidate", case)
|
|
|
+ base_metric, proposed_metric = metric(base), metric(proposed)
|
|
|
+ ok = (base.get("code") == proposed.get("code") == "Ok" and
|
|
|
+ abs(base_metric["duration"] - proposed_metric["duration"]) < 0.2 and
|
|
|
+ proposed_metric["weight"] > base_metric["weight"])
|
|
|
+ check(case + ":weight_not_eta", ok, {"baseline": base_metric, "candidate": proposed_metric})
|
|
|
+ base, proposed = route("baseline", "gravel_choice"), route("candidate", "gravel_choice")
|
|
|
+ check("gravel_preference_changes_path", distance(base) < 300 and distance(proposed) > 350,
|
|
|
+ {"baseline": metric(base), "candidate": metric(proposed)})
|
|
|
+ for profile in ("baseline", "candidate"):
|
|
|
+ for case, expected in (("offroad", "NoSegment"), ("disconnected", "NoRoute")):
|
|
|
+ data = route(profile, case)
|
|
|
+ check(profile + ":" + case, data.get("code") == expected, metric(data))
|
|
|
+ conditional = route("baseline", "conditional_access")
|
|
|
+ # A diagnostic, not a hidden assertion that unsupported time rules work.
|
|
|
+ check("conditional_access_not_enforced", distance(conditional) < 300, metric(conditional), "limitation_probe")
|
|
|
+ repeated = [*samples["motorcycle_no"], samples["motorcycle_no"][0]]
|
|
|
+ coords = ";".join(f"{lon},{lat}" for lon, lat in repeated)
|
|
|
+ multi = read_url(urls["baseline"] + "/route/v1/driving/" + coords + "?overview=false")
|
|
|
+ check("ordered_three_stop_route", multi.get("code") == "Ok" and len(multi["routes"][0]["legs"]) == 2,
|
|
|
+ {"legs": len(multi.get("routes", [{}])[0].get("legs", [])), **metric(multi)})
|
|
|
+ except Exception as error:
|
|
|
+ result["errors"].append(str(error))
|
|
|
+ finally:
|
|
|
+ for identifier in containers:
|
|
|
+ # Only identifiers created by this run are stopped; no Compose
|
|
|
+ # lifecycle command can accidentally target a production service.
|
|
|
+ subprocess.run(["docker", "stop", "--time", "1", identifier], capture_output=True, timeout=15)
|
|
|
+ result["after"] = fingerprints()
|
|
|
+ result["production_files_unchanged"] = result["before"] == result["after"]
|
|
|
+ result["production_containers_running"] = all(
|
|
|
+ command(["docker", "inspect", "--format", "{{.State.Running}}", name]).decode().strip() == "true"
|
|
|
+ for name in production)
|
|
|
+ result["temporary_containers_removed"] = all(
|
|
|
+ subprocess.run(["docker", "inspect", identifier], capture_output=True).returncode != 0
|
|
|
+ for identifier in containers)
|
|
|
+ result["temporary_workspace_removed"] = not Path(result.get("temporary_workspace", "/nonexistent")).exists()
|
|
|
+ print(json.dumps(result, ensure_ascii=False))
|
|
|
+
|
|
|
+
|
|
|
+def main():
|
|
|
+ import inspect
|
|
|
+ sources = {}
|
|
|
+ for path in ("src/sif/motorcyclecost.cc", "src/sif/motorscootercost.cc", "LICENSE.md", "COPYING"):
|
|
|
+ url = f"https://raw.githubusercontent.com/valhalla/valhalla/{VALHALLA_SHA}/{path}"
|
|
|
+ with urllib.request.urlopen(url, timeout=20) as response:
|
|
|
+ data = response.read()
|
|
|
+ sources[path] = {"url": url, "sha256": hashlib.sha256(data).hexdigest(), "bytes": len(data)}
|
|
|
+ refs = {}
|
|
|
+ for ref in ("HEAD", "origin/taiwan-map-profiles"):
|
|
|
+ refs[ref] = subprocess.check_output(["git", "rev-parse", ref], cwd=MAP_REPO).decode().strip()
|
|
|
+ lua = subprocess.check_output(["git", "show", "origin/taiwan-map-profiles:docker/osrm/profiles/motorcycle.lua"], cwd=MAP_REPO)
|
|
|
+ branch_files = {}
|
|
|
+ for ref in refs:
|
|
|
+ branch_files[ref] = {}
|
|
|
+ for path in ("map_api/settings.py", "map_api/routing.py", "docker/osrm/profiles/motorcycle.lua"):
|
|
|
+ snapshot = subprocess.run(["git", "show", ref + ":" + path], cwd=MAP_REPO,
|
|
|
+ stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
|
|
|
+ branch_files[ref][path] = hashlib.sha256(snapshot.stdout).hexdigest() if snapshot.returncode == 0 else None
|
|
|
+ references = {"valhalla_commit": VALHALLA_SHA, "sources": sources, "map_refs": refs, "branch_files": branch_files,
|
|
|
+ "branch_lua_sha256": hashlib.sha256(lua).hexdigest()}
|
|
|
+ source = "import hashlib,json,subprocess,sys,urllib.request\nfrom pathlib import Path\n" + inspect.getsource(remote_probe) + "\nremote_probe()\n"
|
|
|
+ process = subprocess.run(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=8", "tokyo-map", "python3 -"],
|
|
|
+ input=source, text=True, encoding="utf-8", stdout=subprocess.PIPE, timeout=360)
|
|
|
+ if process.returncode:
|
|
|
+ raise RuntimeError("Remote assessment failed before producing a complete result")
|
|
|
+ result = json.loads(process.stdout)
|
|
|
+ result["references"] = references
|
|
|
+ result["branch_lua_matches_deployment"] = references["branch_lua_sha256"] == result["before"]["docker/osrm/profiles/motorcycle.lua"]
|
|
|
+ # Generated machine evidence, not a manually edited source/configuration.
|
|
|
+ OUTPUT.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
|
|
+ failures = [row["name"] for row in result["cases"] if not row["passed"]]
|
|
|
+ print(json.dumps({"cases": len(result["cases"]), "failures": failures, "errors": result["errors"],
|
|
|
+ "files_unchanged": result["production_files_unchanged"], "evidence": str(OUTPUT)}, ensure_ascii=False))
|
|
|
+ if failures or result["errors"] or not all(result[key] for key in
|
|
|
+ ("combined_profile_matches_graph", "branch_lua_matches_deployment", "production_files_unchanged",
|
|
|
+ "production_containers_running", "temporary_containers_removed", "temporary_workspace_removed")):
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+
|
|
|
+if __name__ == "__main__":
|
|
|
+ main()
|
qmj