143 lines
4.5 KiB
Python
143 lines
4.5 KiB
Python
from pathlib import Path
|
|
from subprocess import CalledProcessError, check_output, run
|
|
from time import sleep
|
|
from typing import Optional, Tuple
|
|
|
|
from loguru import logger
|
|
from typing_extensions import Literal
|
|
|
|
from ..version import parse_liquidsoap_version
|
|
from ._connection import LiquidsoapConnection
|
|
|
|
|
|
class LiquidsoapClientError(Exception):
|
|
"""
|
|
A Liquidsoap client error
|
|
"""
|
|
|
|
|
|
class LiquidsoapClient:
|
|
"""
|
|
A client to communicate with a running Liquidsoap server.
|
|
"""
|
|
|
|
conn: LiquidsoapConnection
|
|
|
|
def __init__(
|
|
self,
|
|
host: str = "localhost",
|
|
port: int = 0,
|
|
path: Optional[Path] = None,
|
|
timeout: int = 15,
|
|
):
|
|
self.conn = LiquidsoapConnection(
|
|
host=host,
|
|
port=port,
|
|
path=path,
|
|
timeout=timeout,
|
|
)
|
|
|
|
def version(self) -> Tuple[int, int, int]:
|
|
with self.conn:
|
|
self.conn.write("version")
|
|
return parse_liquidsoap_version(self.conn.read())
|
|
|
|
def wait_for_version(self, timeout: int = 30) -> Tuple[int, int, int]:
|
|
while timeout > 0:
|
|
try:
|
|
version = self.version()
|
|
logger.info(f"found version {version}")
|
|
return version
|
|
except (ConnectionError, TimeoutError) as exception:
|
|
logger.warning(f"could not get version: {exception}")
|
|
timeout -= 1
|
|
sleep(1)
|
|
|
|
raise LiquidsoapClientError("could not get liquidsoap version")
|
|
|
|
def queues_remove(self, *queues: int) -> None:
|
|
with self.conn:
|
|
for queue_id in queues:
|
|
self.conn.write(f"queues.{queue_id}_skip")
|
|
|
|
def queue_push(self, queue_id: int, entry: str, show_name: str) -> None:
|
|
with self.conn:
|
|
self.conn.write(f"{queue_id}.push {entry}")
|
|
self.conn.write(f"vars.show_name {show_name}")
|
|
|
|
def web_stream_get_id(self) -> str:
|
|
with self.conn:
|
|
self.conn.write("dynamic_source.get_id")
|
|
return self.conn.read().splitlines()[0]
|
|
|
|
def web_stream_start(self) -> None:
|
|
with self.conn:
|
|
self.conn.write("streams.scheduled_play_start")
|
|
self.conn.write("dynamic_source.output_start")
|
|
|
|
def web_stream_start_buffer(self, schedule_id: int, uri: str) -> None:
|
|
with self.conn:
|
|
self.conn.write(f"dynamic_source.id {schedule_id}")
|
|
self.conn.write(f"http.restart {uri}")
|
|
|
|
def web_stream_stop(self) -> None:
|
|
with self.conn:
|
|
self.conn.write("dynamic_source.output_stop")
|
|
|
|
def web_stream_stop_buffer(self) -> None:
|
|
with self.conn:
|
|
self.conn.write("http.stop")
|
|
self.conn.write("dynamic_source.id -1")
|
|
|
|
def source_disconnect(self, name: Literal["master_dj", "live_dj"]) -> None:
|
|
command_map = {
|
|
"master_dj": "master_harbor.stop",
|
|
"live_dj": "live_dj_harbor.stop",
|
|
}
|
|
with self.conn:
|
|
self.conn.write(command_map[name])
|
|
|
|
def source_switch_status(
|
|
self,
|
|
name: Literal["master_dj", "live_dj", "scheduled_play"],
|
|
streaming: bool,
|
|
) -> None:
|
|
action = "start" if streaming else "stop"
|
|
with self.conn:
|
|
self.conn.write(f"streams.{name}_{action}")
|
|
|
|
def settings_update(
|
|
self,
|
|
*,
|
|
station_name: Optional[str] = None,
|
|
message_format: Optional[int] = None,
|
|
input_fade_transition: Optional[float] = None,
|
|
):
|
|
with self.conn:
|
|
if station_name is not None:
|
|
self.conn.write(f"vars.station_name {station_name}")
|
|
self.conn.read()
|
|
if message_format is not None:
|
|
self.conn.write(f"vars.stream_metadata_type {message_format}")
|
|
self.conn.read()
|
|
if input_fade_transition is not None:
|
|
self.conn.write(f"vars.default_dj_fade {input_fade_transition}")
|
|
self.conn.read()
|
|
|
|
def restart(self):
|
|
logger.warning("restarting Liquidsoap")
|
|
|
|
try:
|
|
output = check_output(("pidof", "libretime-liquidsoap"))
|
|
liq_pid = output.strip().decode("utf-8")
|
|
logger.debug(f"found liquidsoap pid {liq_pid}")
|
|
|
|
run(("kill", "-9", liq_pid), check=True)
|
|
except CalledProcessError as exception:
|
|
raise LiquidsoapClientError("could not restart liquidsoap") from exception
|
|
|
|
# Wait for the previous process to shutdown.
|
|
sleep(1)
|
|
|
|
self.wait_for_version()
|