sintonia/api-client/libretime_api_client/v1.py

###############################################################################
# This file holds the implementations for all the API clients.
#
# If you want to develop a new client, here are some suggestions: Get the fetch
# methods working first, then the push, then the liquidsoap notifier.  You will
# probably want to create a script on your server side to automatically
# schedule a playlist one minute from the current time.
###############################################################################
import json
import logging
import time
import traceback
import urllib.parse

import requests
from libretime_shared.config import BaseConfig, GeneralConfig

from ._utils import ApiRequest, RequestProvider


class Config(BaseConfig):
    general: GeneralConfig


AIRTIME_API_VERSION = "1.1"


api_endpoints = {}

# URL to get the version number of the server API
api_endpoints["version_url"] = "version/api_key/{api_key}"
# URL to register a components IP Address with the central web server
api_endpoints[
    "register_component"
] = "register-component/format/json/api_key/{api_key}/component/{component}"

# media-monitor
api_endpoints[
    "upload_recorded"
] = "upload-recorded/format/json/api_key/{api_key}/fileid/{fileid}/showinstanceid/{showinstanceid}"
# show-recorder
api_endpoints["show_schedule_url"] = "recorded-shows/format/json/api_key/{api_key}"
api_endpoints["upload_file_url"] = "rest/media"
# pypo
api_endpoints[
    "update_start_playing_url"
] = "notify-media-item-start-play/api_key/{api_key}/media_id/{media_id}/"
api_endpoints[
    "get_stream_setting"
] = "get-stream-setting/format/json/api_key/{api_key}/"
api_endpoints[
    "update_liquidsoap_status"
] = "update-liquidsoap-status/format/json/api_key/{api_key}/msg/{msg}/stream_id/{stream_id}/boot_time/{boot_time}"
api_endpoints[
    "update_source_status"
] = "update-source-status/format/json/api_key/{api_key}/sourcename/{sourcename}/status/{status}"
api_endpoints[
    "check_live_stream_auth"
] = "check-live-stream-auth/format/json/api_key/{api_key}/username/{username}/password/{password}/djtype/{djtype}"
api_endpoints["get_bootstrap_info"] = "get-bootstrap-info/format/json/api_key/{api_key}"
api_endpoints[
    "notify_webstream_data"
] = "notify-webstream-data/api_key/{api_key}/media_id/{media_id}/format/json"
api_endpoints[
    "notify_liquidsoap_started"
] = "rabbitmq-do-push/api_key/{api_key}/format/json"
api_endpoints[
    "get_stream_parameters"
] = "get-stream-parameters/api_key/{api_key}/format/json"
api_endpoints["push_stream_stats"] = "push-stream-stats/api_key/{api_key}/format/json"
api_endpoints[
    "update_stream_setting_table"
] = "update-stream-setting-table/api_key/{api_key}/format/json"
api_endpoints[
    "update_metadata_on_tunein"
] = "update-metadata-on-tunein/api_key/{api_key}"


################################################################################
# Airtime API Version 1 Client
################################################################################
class ApiClient:
    API_BASE = "/api"
    UPLOAD_RETRIES = 3
    UPLOAD_WAIT = 60

    def __init__(self, logger=None, config_path="/etc/libretime/config.yml"):
        self.logger = logger or logging

        config = Config(filepath=config_path)
        self.base_url = config.general.public_url
        self.api_key = config.general.api_key

        self.services = RequestProvider(
            base_url=self.base_url + self.API_BASE,
            api_key=self.api_key,
            endpoints=api_endpoints,
        )

    def __get_api_version(self):
        try:
            return self.services.version_url()["api_version"]
        except Exception as e:
            self.logger.exception(e)
            return -1

    def is_server_compatible(self, verbose=True):
        logger = self.logger
        api_version = self.__get_api_version()
        # logger.info('Airtime version found: ' + str(version))
        if api_version == -1:
            if verbose:
                logger.info("Unable to get Airtime API version number.\n")
            return False
        elif api_version[0:3] != AIRTIME_API_VERSION[0:3]:
            if verbose:
                logger.info("Airtime API version found: " + str(api_version))
                logger.info(
                    "pypo is only compatible with API version: " + AIRTIME_API_VERSION
                )
            return False
        else:
            if verbose:
                logger.info("Airtime API version found: " + str(api_version))
                logger.info(
                    "pypo is only compatible with API version: " + AIRTIME_API_VERSION
                )
            return True

    def notify_liquidsoap_started(self):
        try:
            self.services.notify_liquidsoap_started()
        except Exception as e:
            self.logger.exception(e)

    def notify_media_item_start_playing(self, media_id):
        """This is a callback from liquidsoap, we use this to notify
        about the currently playing *song*. We get passed a JSON string
        which we handed to liquidsoap in get_liquidsoap_data()."""
        try:
            return self.services.update_start_playing_url(media_id=media_id)
        except Exception as e:
            self.logger.exception(e)
            return None

    def get_shows_to_record(self):
        try:
            return self.services.show_schedule_url()
        except Exception as e:
            self.logger.exception(e)
            return None

    def upload_recorded_show(self, files, show_id):
        logger = self.logger
        response = ""

        retries = self.UPLOAD_RETRIES
        retries_wait = self.UPLOAD_WAIT

        url = self.construct_rest_url("upload_file_url")

        logger.debug(url)

        for i in range(0, retries):
            logger.debug("Upload attempt: %s", i + 1)
            logger.debug(files)
            logger.debug(ApiRequest.API_HTTP_REQUEST_TIMEOUT)

            try:
                request = requests.post(
                    url, files=files, timeout=float(ApiRequest.API_HTTP_REQUEST_TIMEOUT)
                )
                response = request.json()
                logger.debug(response)

                """
                FIXME: We need to tell LibreTime that the uploaded track was recorded for a specific show

                My issue here is that response does not yet have an id. The id gets generated at the point
                where analyzer is done with it's work. We probably need to do what is below in analyzer
                and also make sure that the show instance id is routed all the way through.

                It already gets uploaded by this but the RestController does not seem to care about it. In
                the end analyzer doesn't have the info in it's rabbitmq message and imports the show as a
                regular track.

                logger.info("uploaded show result as file id %s", response.id)

                url = self.construct_url("upload_recorded")
                url = url.replace('%%fileid%%', response.id)
                url = url.replace('%%showinstanceid%%', show_id)
                request.get(url)
                logger.info("associated uploaded file %s with show instance %s", response.id, show_id)
                """
                break

            except requests.exceptions.HTTPError as exception:
                logger.error(f"Http error code: {exception.response.status_code}")
                logger.error("traceback: %s", traceback.format_exc())
            except requests.exceptions.ConnectionError as e:
                logger.error("Server is down: %s", e.args)
                logger.error("traceback: %s", traceback.format_exc())
            except Exception as e:
                self.logger.exception(e)

            # wait some time before next retry
            time.sleep(retries_wait)

        return response

    def check_live_stream_auth(self, username, password, dj_type):
        try:
            return self.services.check_live_stream_auth(
                username=username, password=password, djtype=dj_type
            )
        except Exception as e:
            self.logger.exception(e)
            return {}

    def construct_rest_url(self, action_key):
        """
        Constructs the base url for RESTful requests
        """
        url = urllib.parse.urlsplit(self.base_url)
        url.username = self.api_key
        return f"{url.geturl()}/{api_endpoints[action_key]}"

    def get_stream_setting(self):
        return self.services.get_stream_setting()

    def register_component(self, component):
        """Purpose of this method is to contact the server with a "Hey its
        me!" message. This will allow the server to register the component's
        (component = media-monitor, pypo etc.) ip address, and later use it
        to query monit via monit's http service, or download log files via a
        http server."""
        return self.services.register_component(component=component)

    def notify_liquidsoap_status(self, msg, stream_id, time):
        logger = self.logger
        try:
            # encoded_msg is no longer used server_side!!
            encoded_msg = urllib.parse.quote("dummy")

            self.services.update_liquidsoap_status.req(
                _post_data={"msg_post": msg},
                msg=encoded_msg,
                stream_id=stream_id,
                boot_time=time,
            ).retry(5)
        except Exception as e:
            self.logger.exception(e)

    def notify_source_status(self, sourcename, status):
        try:
            return self.services.update_source_status.req(
                sourcename=sourcename, status=status
            ).retry(5)
        except Exception as e:
            self.logger.exception(e)

    def get_bootstrap_info(self):
        """Retrieve infomations needed on bootstrap time"""
        return self.services.get_bootstrap_info()

    def notify_webstream_data(self, data, media_id):
        """
        Update the server with the latest metadata we've received from the
        external webstream
        """
        self.logger.info(
            self.services.notify_webstream_data.req(
                _post_data={"data": data}, media_id=str(media_id)
            ).retry(5)
        )

    def get_stream_parameters(self):
        response = self.services.get_stream_parameters()
        self.logger.debug(response)
        return response

    def push_stream_stats(self, data):
        # TODO : users of this method should do their own error handling
        response = self.services.push_stream_stats(
            _post_data={"data": json.dumps(data)}
        )
        return response

    def update_stream_setting_table(self, data):
        try:
            response = self.services.update_stream_setting_table(
                _post_data={"data": json.dumps(data)}
            )
            return response
        except Exception as e:
            self.logger.exception(e)

    def update_metadata_on_tunein(self):
        self.services.update_metadata_on_tunein()


class InvalidContentType(Exception):
    pass