observe_pipewire.py 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139
  1. import argparse
  2. import json
  3. import re
  4. import subprocess
  5. import sys
  6. from pathlib import Path
  7. import yaml
  8. from validate_desired_state import validate_state as validate_desired_state
  9. MANAGED_ENDPOINT_PATTERN = re.compile(
  10. r"^alsa_(?:input|output)\.hw_U192k_0:(?:capture|playback)_AUX[0-3]$"
  11. )
  12. def load_state(path):
  13. with path.open(encoding="utf-8") as state_stream:
  14. state = yaml.safe_load(state_stream)
  15. errors = validate_desired_state(state)
  16. errors.extend(validate_managed_links(state))
  17. if errors:
  18. raise ValueError("invalid desired state: " + "; ".join(errors))
  19. return state
  20. def validate_managed_links(state):
  21. errors = []
  22. if not isinstance(state, dict):
  23. return ["document root must be a mapping"]
  24. routing = state.get("routing")
  25. if not isinstance(routing, dict):
  26. return ["routing must be a mapping"]
  27. managed_ports = routing.get("managed_ports")
  28. if not isinstance(managed_ports, list):
  29. errors.append("routing.managed_ports must be a list")
  30. managed_ports = []
  31. for index, port in enumerate(managed_ports):
  32. if not isinstance(port, str) or not MANAGED_ENDPOINT_PATTERN.fullmatch(port):
  33. errors.append(f"routing.managed_ports[{index}] must be a concrete UMC AUX port")
  34. if len(managed_ports) != len(set(port for port in managed_ports if isinstance(port, str))):
  35. errors.append("routing.managed_ports must not contain duplicate ports")
  36. managed_links = routing.get("managed_links")
  37. if not isinstance(managed_links, list):
  38. errors.append("routing.managed_links must be a list")
  39. managed_links = []
  40. for index, link in enumerate(managed_links):
  41. if not isinstance(link, dict):
  42. errors.append(f"routing.managed_links[{index}] must be a mapping")
  43. continue
  44. source = link.get("from")
  45. destination = link.get("to")
  46. if not isinstance(source, str) or not MANAGED_ENDPOINT_PATTERN.fullmatch(source):
  47. errors.append(f"routing.managed_links[{index}].from must be a concrete UMC AUX port")
  48. if not isinstance(destination, str) or not MANAGED_ENDPOINT_PATTERN.fullmatch(destination):
  49. errors.append(f"routing.managed_links[{index}].to must be a concrete UMC AUX port")
  50. if (
  51. isinstance(source, str)
  52. and isinstance(destination, str)
  53. and (source not in managed_ports or destination not in managed_ports)
  54. ):
  55. errors.append(f"routing.managed_links[{index}] endpoints must be listed in routing.managed_ports")
  56. if source == destination:
  57. errors.append(f"routing.managed_links[{index}] cannot link a port to itself")
  58. if link.get("status") not in {"planned", "observed"}:
  59. errors.append(f"routing.managed_links[{index}].status must be planned or observed")
  60. return errors
  61. def parse_pw_link_output(text):
  62. links = set()
  63. current_source = None
  64. for line in text.splitlines():
  65. if not line.strip():
  66. continue
  67. if line.startswith(" |-> "):
  68. if current_source is None:
  69. raise ValueError("pw-link output has a destination without a source")
  70. destination = line.removeprefix(" |-> ")
  71. links.add((current_source, destination))
  72. continue
  73. if line.startswith(" |<- "):
  74. destination = line.removeprefix(" |<- ")
  75. links.add((destination, current_source))
  76. continue
  77. current_source = line.strip()
  78. return links
  79. def observe(state, links):
  80. managed_ports = set(state["routing"]["managed_ports"])
  81. managed = {
  82. (link["from"], link["to"])
  83. for link in state["routing"]["managed_links"]
  84. if link["status"] in {"planned", "observed"}
  85. }
  86. observed_managed = {
  87. link
  88. for link in links
  89. if link[0] in managed_ports and link[1] in managed_ports
  90. }
  91. reports = []
  92. for source, destination in sorted(managed - observed_managed):
  93. reports.append({"kind": "missing", "from": source, "to": destination, "action": "would-link"})
  94. for source, destination in sorted(observed_managed - managed):
  95. reports.append({"kind": "unexpected", "from": source, "to": destination, "action": "would-review"})
  96. return reports
  97. def main(argv=None):
  98. parser = argparse.ArgumentParser()
  99. parser.add_argument(
  100. "--state",
  101. type=Path,
  102. default=Path(__file__).resolve().parents[1] / "config" / "desired-state.yaml",
  103. )
  104. args = parser.parse_args(argv)
  105. try:
  106. state = load_state(args.state)
  107. result = subprocess.run(
  108. ["pw-link", "-l"],
  109. check=True,
  110. capture_output=True,
  111. text=True,
  112. )
  113. links = parse_pw_link_output(result.stdout)
  114. except (OSError, subprocess.CalledProcessError, ValueError, yaml.YAMLError) as error:
  115. print(f"ERROR: {error}", file=sys.stderr)
  116. return 2
  117. reports = observe(state, links)
  118. print(json.dumps({"mode": "observe-only", "managed_links": len(state["routing"]["managed_links"]), "differences": reports}, indent=2))
  119. return 0
  120. if __name__ == "__main__":
  121. raise SystemExit(main())