client.py

#
# Aura Engine (https://gitlab.servus.at/aura/engine)
#
# Copyright (C) 2017-2020 - The Aura Engine Team.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import socket
import urllib.parse
import configparser
import logging

from multiprocessing import Lock

from modules.base.exceptions import LQConnectionError
from modules.base.utils import TerminalColors

""" 
    LiquidSoapClient Class 
    Connects to a LiquidSoap instance over a socket and sends commands to it
"""


class LiquidSoapClient:
    mutex = None
    logger = None
    debug = False
    socket_path = ""
    disable_logging = True

    def __init__(self, config, socket_filename):
        """
        Constructor
        @type    socket_path: string
        @param   socket_path: Der Pfad zum Socket des Liquidsoap-Scripts
        """
        self.logger = logging.getLogger("AuraEngine")
        self.socket_path = config.get('socketdir') + '/' + socket_filename

        self.logger.debug("LiquidSoapClient using socketpath: " + self.socket_path)

        # init
        self.mutex = Lock()
        self.connected = False
        self.can_connect = True
        self.message = ''
        self.socket = None
        self.metareader = configparser.ConfigParser()

    # ------------------------------------------------------------------------------------------ #
    def connect(self):
        """
        Verbindung herstellen
        """
        try:
            self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.socket.connect(self.socket_path)
        except socket.error as e:
            msg = "Cannot connect to socketpath " + self.socket_path + ". Reason: "+str(e)
            self.logger.critical(TerminalColors.RED.value+msg+TerminalColors.ENDC.value)
            self.can_connect = False
            self.connected = False
#            raise e
        else:
            self.can_connect = True
            self.connected = True
            return True


# AttributeError('characters_written')

    # ------------------------------------------------------------------------------------------ #
    def is_connected(self):
        return self.connected

    # ------------------------------------------------------------------------------------------ #
    def write(self, data):
        """
        Auf den Socket schreiben
        @type    data: string
        @param   data: Der String der gesendet wird
        """
        if self.connected:
            self.socket.sendall(data.decode("UTF-8"))

    # ------------------------------------------------------------------------------------------ #
    def read_all(self, timeout=2):
        """
        Vom Socket lesen, bis dieser "END" sendet
        @type    timeout: int
        @param   timeout: Ein optionales Timeout
        @rtype:  string
        @return: Die Antwort des Liquidsoap-Servers
        """
        # make socket non blocking
        # self.client.setblocking(0)

        data = ''

        try:
            # set timeout
            self.socket.settimeout(timeout)

            # acquire the lock
            self.mutex.acquire()

            while True:
                data += self.socket.recv(1).decode("utf-8")

                # receive as long as we are not at the END or recv a Bye! from liquidsoap
                if data.find("END\r\n") != -1 or data.find("Bye!\r\n") != -1:
                    data.replace("END\r\n", "")
                    break

            # release the lock
            self.mutex.release()

        except Exception as e:
            self.logger.error(TerminalColors.RED.value+str(e)+TerminalColors.ENDC.value)
            self.mutex.release()

        return data

    # ------------------------------------------------------------------------------------------ #
    def read(self):
        """
        read from socket and store return value in self.message
        @rtype:  string
        @return: The answer of liquidsoap server
        """
        if self.connected:
            ret = self.read_all().splitlines()

            try:
                last = ret.pop() # pop out end

                if len(ret) > 1:
                    self.message = str.join(" - ", ret)
                elif len(ret) == 1:
                    self.message = ret[0]

                if last == "Bye!":
                    self.message = last

            except Exception as e:
                self.logger.error(str(e))

            return self.message

    # ------------------------------------------------------------------------------------------ #
    def close(self):
        """
        Quit senden und Verbindung schließen
        """
        if self.connected:
            message = "quit\r"
            self.socket.sendall(message.decode("UTF-8"))
            self.socket.close()
            self.connected = False

    # ------------------------------------------------------------------------------------------ #
    def command(self, namespace, command, param=""):
        """
        Kommando an Liquidosap senden
        @type    command:   string
        @param   command:   Kommando
        @type    namespace: string
        @param   namespace: Namespace/Kanal der angesprochen wird
        @type    param:     mixed
        @param   param:     ein optionaler Parameter
        @rtype:  string
        @return: Die Antwort des Liquidsoap-Servers
        """

        param = (param.strip() if param.strip() == "" else " " + urllib.parse.unquote(param.strip()))
        if self.connected:
            # print namespace + '.' + command + param + "\n"
            if namespace is "":
                message = str(command) + str(param) + str("\n")
            else:
                message = str(namespace) + str(".") + str(command) + str(param) + str("\n")

            try:
                if not self.disable_logging:
                    self.logger.debug("LiquidSoapClient sending to LiquidSoap Server: " + message[0:len(message)-1])

                # send all the stuff over the socket to liquidsoap server
                self.socket.sendall(message.encode())

                if not self.disable_logging:
                    self.logger.debug("LiquidSoapClient waiting for reply from LiquidSoap Server")

                # wait for reply
                self.read()

                if not self.disable_logging:
                    self.logger.debug("LiquidSoapClient got reply: " + self.message)
            except BrokenPipeError as e:
                self.logger.error(TerminalColors.RED.value+"Detected a problem with liquidsoap connection while sending: " + message + ". Reason: " + str(e) + "! Trying to reconnect."+TerminalColors.RED.value)
                self.connect()
                raise

            except Exception as e:
                self.logger.error("Unexpected error: " + str(e))
                raise

            return self.message
        else:
            msg = "LiquidsoapClient not connected to LiquidSoap Server"
            self.logger.error(msg)
            raise LQConnectionError(msg)

    # ------------------------------------------------------------------------------------------ #
    def help(self):
        """
        get liquidsoap server help
        @rtype:  string
        @return: the response of the liquidsoap server
        """
        if self.connected:
            self.command('help', '')
            return self.message

    # ------------------------------------------------------------------------------------------ #
    def version(self):
        """
        Liquidsoap get version
        @rtype:  string
        @return: the response of the liquidsoap server
        """
        if self.connected:
            message = 'version'
            self.command(message, '')
            return self.message

    # ------------------------------------------------------------------------------------------ #
    def uptime(self):
        """
        Liquidsoap get uptime
        @rtype:  string
        @return: Die Antwort des Liquidsoap-Servers
        """

        if self.connected:
            self.command('uptime', '')
            return self.message

    # ------------------------------------------------------------------------------------------ #
    def byebye(self):
        """
        Liquidsoap say byebye
        @rtype:  string
        @return: Die Antwort des Liquidsoap-Servers
        """

        if self.connected:
            self.command("", "quit")
            return self.message