libraries/security/whitelist.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#       aurawhitelist
+#
+"""
+Aura Whitelist  - IP-Adressen oder Domains aus der Whitelist holen
+"""
+import os
+import sys
+import redis
+
+
+"""
+Whitelisting ips or hostnames
+"""
+class AuraWhitelist(object):
+    def __init__(self):
+        self.db = redis.Redis()
+        self.dbname = 'aurawhitelist'
+        pass
+    # ------------------------------------------------------------------------------------------ #
+    def getList(self):
+        """
+        get the whitelist
+        :return: list - list of whitelisted ip's
+        """
+        return self.db.lrange(self.dbname, 0, -1)
+
+    # ------------------------------------------------------------------------------------------ #
+    def add(self,address):
+        """
+        Add ip/host to whitelist
+        :param address: string - ip or hostname
+        :return: boolean
+        """
+        list = self.getList()
+        for item in list:
+            if item == address:
+                return False
+        self.db.lpush(self.dbname, address)
+        return True
+
+    # ------------------------------------------------------------------------------------------ #
+    def remove(self,address):
+        """
+        Remove an ip or host from whitelist
+        :param address: string - ip or hostname
+        :return: boolean
+        """
+        if not address:
+            return False
+        self.db.lrem(self.dbname, address, 1)
+        return True
+

modules/base/config.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#       combabase.py
+#
+#       Copyright 2014 BFR <info@freie-radios.de>
+#
+#       This program is free software; you can redistribute it and/or modify
+#       it under the terms of the GNU General Public License as published by
+#       the Free Software Foundation; Version 3 of the License
+#
+#       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 General Public License for more details.
+#
+#       You should have received a copy of the GNU General Public License
+#       along with this program; if not, the license can be downloaded here:
+#
+#       http://www.gnu.org/licenses/gpl.html
+
+# Meta
+__version__ = '0.1.1'
+__license__ = "GNU General Public License (GPL) Version 3"
+__version_info__ = (0, 1, 1)
+__author__ = 'Michael Liebler <michael-liebler@radio-z.net>'
+
+# massively enhanced by Gottfried Gaisbauer <gottfried.gaisbauer@servus.at>
+
+"""
+Comba Base Class  - lade Config
+"""
+import os
+import sys
+import socket
+import logging
+
+from configparser import ConfigParser
+
+
+class ConfigReader(object):
+    ini_path = ""
+    logger = None
+
+    def __init__(self):
+        self.logger = logging.getLogger("AuraEngine")
+
+    def set(self, key, value):
+        """
+        Eine property setzen
+        @type    key: string
+        @param   key: Der Key
+        @type    value: mixed
+        @param   value: Beliebiger Wert
+        """
+        if key == "securitylevel":
+            self.__dict__[key] = int(value)
+        else:
+            self.__dict__[key] = value
+
+    # ------------------------------------------------------------------------------------------ #
+    def get(self, key, default=None):
+        """
+        Eine property holen
+        @type    key: string
+        @param   key: Der Key
+        @type    default: mixed
+        @param   default: Beliebiger Wert
+
+        """
+        if key not in self.__dict__:
+            if default:
+                self.set(key, default)
+            else:
+                self.logger.warning("Key " + key + " not found in configfile " + self.ini_path + "!")
+                return None
+
+        if key == "loglevel":
+            loglvl = self.__dict__[key]
+
+            if loglvl == "debug":
+                return logging.DEBUG
+            elif loglvl == "info":
+                return logging.INFO
+            elif loglvl == "warning":
+                return logging.WARNING
+            elif loglvl == "error":
+                return logging.ERROR
+            else:
+                return logging.CRITICAL
+
+        if key == "debug":
+            return self.__dict__[key].count("y")
+
+        return self.__dict__[key]
+
+    # ------------------------------------------------------------------------------------------ #
+    def load_config(self):
+        """
+        Set config defaults and load settings from file
+        :return:
+        """
+        self.ini_path = self.get('configpath', '/etc/aura/aura.ini')
+
+        if not os.path.isfile(self.ini_path):
+            self.logger.critical(self.ini_path + " not found  :(")
+            sys.exit(1)
+
+        # INI einlesen
+        f = open(self.ini_path, 'r')
+        #ini_str = '[root]\n' + f.read()
+        ini_str = f.read()
+        f.close()
+
+        config_parser = ConfigParser()
+        try:
+            config_parser.read_string(ini_str)
+        except Exception as e:
+            self.logger.critical("Cannot read " + self.ini_path + "! Reason: " + str(e))
+            sys.exit(0)
+
+        for section in config_parser.sections():
+            for key, value in config_parser.items(section):
+                v = config_parser.get(section, key).replace('"', '').strip()
+                self.set(key, v)
+
+

modules/base/parsexml.py

+#!/usr/bin/env python
+"Makes working with XML feel like you are working with JSON"
+
+from xml.parsers import expat
+from xml.sax.saxutils import XMLGenerator
+from xml.sax.xmlreader import AttributesImpl
+try:  # pragma no cover
+    from cStringIO import StringIO
+except ImportError:  # pragma no cover
+    try:
+        from StringIO import StringIO
+    except ImportError:
+        from io import StringIO
+try:  # pragma no cover
+    from collections import OrderedDict
+except ImportError:  # pragma no cover
+    try:
+        from ordereddict import OrderedDict
+    except ImportError:
+        OrderedDict = dict
+
+try:  # pragma no cover
+    _basestring = str #basestring
+except NameError:  # pragma no cover
+    _basestring = bytes #str
+try:  # pragma no cover
+    _unicode = str #unicode
+except NameError:  # pragma no cover
+    _unicode = bytes #str
+
+__author__ = 'Martin Blech'
+__version__ = '0.9.0'
+__license__ = 'MIT'
+
+
+class ParsingInterrupted(Exception):
+    pass
+
+
+class _DictSAXHandler(object):
+    def __init__(self,
+                 item_depth=0,
+                 item_callback=lambda *args: True,
+                 xml_attribs=True,
+                 attr_prefix='@',
+                 cdata_key='#text',
+                 force_cdata=False,
+                 cdata_separator='',
+                 postprocessor=None,
+                 dict_constructor=OrderedDict,
+                 strip_whitespace=True,
+                 namespace_separator=':',
+                 namespaces=None):
+        self.path = []
+        self.stack = []
+        self.data = None
+        self.item = None
+        self.item_depth = item_depth
+        self.xml_attribs = xml_attribs
+        self.item_callback = item_callback
+        self.attr_prefix = attr_prefix
+        self.cdata_key = cdata_key
+        self.force_cdata = force_cdata
+        self.cdata_separator = cdata_separator
+        self.postprocessor = postprocessor
+        self.dict_constructor = dict_constructor
+        self.strip_whitespace = strip_whitespace
+        self.namespace_separator = namespace_separator
+        self.namespaces = namespaces
+
+    def _build_name(self, full_name):
+        if not self.namespaces:
+            return full_name
+        i = full_name.rfind(self.namespace_separator)
+        if i == -1:
+            return full_name
+        namespace, name = full_name[:i], full_name[i+1:]
+        short_namespace = self.namespaces.get(namespace, namespace)
+        if not short_namespace:
+            return name
+        else:
+            return self.namespace_separator.join((short_namespace, name))
+
+    def _attrs_to_dict(self, attrs):
+        if isinstance(attrs, dict):
+            return attrs
+        return self.dict_constructor(zip(attrs[0::2], attrs[1::2]))
+
+    def startElement(self, full_name, attrs):
+        name = self._build_name(full_name)
+        attrs = self._attrs_to_dict(attrs)
+        self.path.append((name, attrs or None))
+        if len(self.path) > self.item_depth:
+            self.stack.append((self.item, self.data))
+            if self.xml_attribs:
+                attrs = self.dict_constructor(
+                    (self.attr_prefix+key, value)
+                    for (key, value) in attrs.items())
+            else:
+                attrs = None
+            self.item = attrs or None
+            self.data = None
+
+    def endElement(self, full_name):
+        name = self._build_name(full_name)
+        if len(self.path) == self.item_depth:
+            item = self.item
+            if item is None:
+                item = self.data
+            should_continue = self.item_callback(self.path, item)
+            if not should_continue:
+                raise ParsingInterrupted()
+        if len(self.stack):
+            item, data = self.item, self.data
+            self.item, self.data = self.stack.pop()
+            if self.strip_whitespace and data is not None:
+                data = data.strip() or None
+            if data and self.force_cdata and item is None:
+                item = self.dict_constructor()
+            if item is not None:
+                if data:
+                    self.push_data(item, self.cdata_key, data)
+                self.item = self.push_data(self.item, name, item)
+            else:
+                self.item = self.push_data(self.item, name, data)
+        else:
+            self.item = self.data = None
+        self.path.pop()
+
+    def characters(self, data):
+        if not self.data:
+            self.data = data
+        else:
+            self.data += self.cdata_separator + data
+
+    def push_data(self, item, key, data):
+        if self.postprocessor is not None:
+            result = self.postprocessor(self.path, key, data)
+            if result is None:
+                return item
+            key, data = result
+        if item is None:
+            item = self.dict_constructor()
+        try:
+            value = item[key]
+            if isinstance(value, list):
+                value.append(data)
+            else:
+                item[key] = [value, data]
+        except KeyError:
+            item[key] = data
+        return item
+
+
+def parsexml(xml_input, encoding=None, expat=expat, process_namespaces=False,
+          namespace_separator=':', **kwargs):
+    """Parse the given XML input and convert it into a dictionary.
+
+    `xml_input` can either be a `string` or a file-like object.
+
+    If `xml_attribs` is `True`, element attributes are put in the dictionary
+    among regular child elements, using `@` as a prefix to avoid collisions. If
+    set to `False`, they are just ignored.
+
+    Simple example::
+
+        >>> import xmltodict
+        >>> doc = xmltodict.parse(\"\"\"
+        ... <a prop="x">
+        ...   <b>1</b>
+        ...   <b>2</b>
+        ... </a>
+        ... \"\"\")
+        >>> doc['a']['@prop']
+        u'x'
+        >>> doc['a']['b']
+        [u'1', u'2']
+
+    If `item_depth` is `0`, the function returns a dictionary for the root
+    element (default behavior). Otherwise, it calls `item_callback` every time
+    an item at the specified depth is found and returns `None` in the end
+    (streaming mode).
+
+    The callback function receives two parameters: the `path` from the document
+    root to the item (name-attribs pairs), and the `item` (dict). If the
+    callback's return value is false-ish, parsing will be stopped with the
+    :class:`ParsingInterrupted` exception.
+
+    Streaming example::
+
+        >>> def handle(path, item):
+        ...     print 'path:%s item:%s' % (path, item)
+        ...     return True
+        ...
+        >>> xmltodict.parse(\"\"\"
+        ... <a prop="x">
+        ...   <b>1</b>
+        ...   <b>2</b>
+        ... </a>\"\"\", item_depth=2, item_callback=handle)
+        path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:1
+        path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:2
+
+    The optional argument `postprocessor` is a function that takes `path`,
+    `key` and `value` as positional arguments and returns a new `(key, value)`
+    pair where both `key` and `value` may have changed. Usage example::
+
+        >>> def postprocessor(path, key, value):
+        ...     try:
+        ...         return key + ':int', int(value)
+        ...     except (ValueError, TypeError):
+        ...         return key, value
+        >>> xmltodict.parse('<a><b>1</b><b>2</b><b>x</b></a>',
+        ...                 postprocessor=postprocessor)
+        OrderedDict([(u'a', OrderedDict([(u'b:int', [1, 2]), (u'b', u'x')]))])
+
+    You can pass an alternate version of `expat` (such as `defusedexpat`) by
+    using the `expat` parameter. E.g:
+
+        >>> import defusedexpat
+        >>> xmltodict.parse('<a>hello</a>', expat=defusedexpat.pyexpat)
+        OrderedDict([(u'a', u'hello')])
+
+    """
+    handler = _DictSAXHandler(namespace_separator=namespace_separator,
+                              **kwargs)
+    if isinstance(xml_input, _unicode):
+        if not encoding:
+            encoding = 'utf-8'
+        xml_input = xml_input.encode(encoding)
+    if not process_namespaces:
+        namespace_separator = None
+    parser = expat.ParserCreate(
+        encoding,
+        namespace_separator
+    )
+    try:
+        parser.ordered_attributes = True
+    except AttributeError:
+        # Jython's expat does not support ordered_attributes
+        pass
+    parser.StartElementHandler = handler.startElement
+    parser.EndElementHandler = handler.endElement
+    parser.CharacterDataHandler = handler.characters
+    parser.buffer_text = True
+    try:
+        parser.ParseFile(xml_input)
+    except (TypeError, AttributeError):
+        parser.Parse(xml_input, True)
+    return handler.item
+
+
+def _emit(key, value, content_handler,
+          attr_prefix='@',
+          cdata_key='#text',
+          depth=0,
+          preprocessor=None,
+          pretty=False,
+          newl='\n',
+          indent='\t'):
+    if preprocessor is not None:
+        result = preprocessor(key, value)
+        if result is None:
+            return
+        key, value = result
+    if not isinstance(value, (list, tuple)):
+        value = [value]
+    if depth == 0 and len(value) > 1:
+        raise ValueError('document with multiple roots')
+    for v in value:
+        if v is None:
+            v = OrderedDict()
+        elif not isinstance(v, dict):
+            v = _unicode(v)
+        if isinstance(v, _basestring):
+            v = OrderedDict(((cdata_key, v),))
+        cdata = None
+        attrs = OrderedDict()
+        children = []
+        for ik, iv in v.items():
+            if ik == cdata_key:
+                cdata = iv
+                continue
+            if ik.startswith(attr_prefix):
+                attrs[ik[len(attr_prefix):]] = iv
+                continue
+            children.append((ik, iv))
+        if pretty:
+            content_handler.ignorableWhitespace(depth * indent)
+        content_handler.startElement(key, AttributesImpl(attrs))
+        if pretty and children:
+            content_handler.ignorableWhitespace(newl)
+        for child_key, child_value in children:
+            _emit(child_key, child_value, content_handler,
+                  attr_prefix, cdata_key, depth+1, preprocessor,
+                  pretty, newl, indent)
+        if cdata is not None:
+            content_handler.characters(cdata)
+        if pretty and children:
+            content_handler.ignorableWhitespace(depth * indent)
+        content_handler.endElement(key)
+        if pretty and depth:
+            content_handler.ignorableWhitespace(newl)
+
+
+def unparse(input_dict, output=None, encoding='utf-8', full_document=True, **kwargs):
+
+    """Emit an XML document for the given `input_dict` (reverse of `parse`).
+    The resulting XML document is returned as a string, but if `output`
+    (afile-like object) is specified, it is written there instead.
+    Dictionary keys prefixed with `attr_prefix` (default=`'@'`) are interpreted
+    as XML node attributes, whereas keys equal to `cdata_key`
+    (default=`'#text'`) are treated as character data.
+    The `pretty` parameter (default=`False`) enables pretty-printing. In this
+    mode, lines are terminated with `'\n'` and indented with `'\t'`, but this
+    can be customized with the `newl` and `indent` parameters.
+    """
+    ((key, value),) = input_dict.items()
+    must_return = False
+    if output is None:
+        output = StringIO()
+        must_return = True
+    content_handler = XMLGenerator(output, encoding)
+    if full_document:
+        content_handler.startDocument()
+    _emit(key, value, content_handler, **kwargs)
+    if full_document:
+        content_handler.endDocument()
+    if must_return:
+        value = output.getvalue()
+        try:  # pragma no cover
+            value = value.decode(encoding)
+        except AttributeError:  # pragma no cover
+            pass
+        return value
+
+if __name__ == '__main__':  # pragma: no cover
+    import sys
+    import marshal
+
+    (item_depth,) = sys.argv[1:]
+    item_depth = int(item_depth)
+
+    def handle_item(path, item):
+        marshal.dump((path, item), sys.stdout)
+        return True
+
+    try:
+        root = parsexml(sys.stdin,
+                     item_depth=item_depth,
+                     item_callback=handle_item,
+                     dict_constructor=dict)
+        if item_depth == 0:
+            handle_item([], root)
+    except KeyboardInterrupt:
+        pass

modules/cli_tool/padavan.py

+import simplejson
+
+from libraries.enum.redischannel import RedisChannel
+from modules.communication.redis.adapter import ClientRedisAdapter, ServerRedisAdapter
+from modules.communication.redis.messenger import RedisMessenger
+
+
+class Padavan:
+    args = None
+    config = None
+
+    lsc = None
+    zmqclient = None
+    redisclient = None
+    stringreply = ""
+
+    # ------------------------------------------------------------------------------------------ #
+    def __init__(self, args, config):
+        self.args = args
+        self.config = config
+
+    # ------------------------------------------------------------------------------------------ #
+    def meditate(self):
+        if self.args.fetch_new_programme:
+            self.fetch_new_programme()
+
+        elif self.args.get_active_mixer:
+            self.get_active_mixer()
+
+        elif self.args.get_mixer_status:
+            self.get_mixer_status()
+
+        elif self.args.get_act_programme:
+            self.get_act_programme()
+
+#        elif self.args.add_source:
+#            print("Guru still has to learn to add a source")
+
+        elif self.args.redis_message:
+            self.redis_message(self.args.redis_message[0], self.args.redis_message[1])
+
+        elif self.args.select_mixer != -1:
+            self.select_mixer(self.args.select_mixer)
+
+        elif self.args.deselect_mixer != -1:
+            self.select_mixer(self.args.deselect_mixer, False)
+
+        elif self.args.set_volume:
+            self.set_volume(self.args.set_volume[0], self.args.set_volume[1])
+
+        elif self.args.swap_playlist_entries:
+            self.swap_playlist_entries(self.args.swap_playlist_entries[0], self.args.swap_playlist_entries[1])
+
+        elif self.args.delete_playlist_entry:
+            self.delete_playlist_entry(self.args.delete_playlist_entry[0])
+
+        elif self.args.insert_playlist_entry:
+            self.insert_playlist_entry(self.args.insert_playlist_entry[0], self.args.insert_playlist_entry[1]) #, self.args.insert_playlist_entry[2])
+
+        elif self.args.print_message_queue:
+            self.print_message_queue()
+
+        elif self.args.get_file_for:
+            self.get_next_file(self.args.get_file_for)
+
+        elif self.args.set_file_for:
+            self.set_next_file(self.args.set_file_for[0], self.args.set_file_for[1])
+
+        elif self.args.now_playing:
+            print("")
+
+        elif self.args.init_player:
+            self.init_player()
+
+        # else:
+        #    raise Exception("")
+
+    # init liquid => faster exec time, when loading at runtime just what is needed
+    def init_liquidsoap_communication(self):
+        # import
+        from modules.communication.liquidsoap.communicator import LiquidSoapCommunicator
+
+        # init liquidsoap communication
+        self.lsc = LiquidSoapCommunicator(self.config)
+        # enable connection
+        self.lsc.enable_transaction()
+
+    def destroy_liquidsoap_communication(self):
+        # enable connection
+        self.lsc.disable_transaction()
+
+    def init_redis_communication(self, with_server=False):
+        self.redisclient = ClientRedisAdapter()
+
+        if with_server:
+            self.redisserver = ServerRedisAdapter()
+
+    def send_redis(self, channel, message):
+        self.init_redis_communication()
+        self.redisclient.publish(channel, message)
+
+    def send_and_wait_redis(self, channel, message, reply_channel):
+        self.init_redis_communication(True)
+        self.redisclient.publish(channel, message)
+        return self.redisserver.listen_for_one_message(reply_channel.value)
+
+    def fetch_new_programme(self):
+        json_reply = self.send_and_wait_redis("aura", "fetch_new_programme", RedisChannel.FNP_REPLY)
+        actprogramme = simplejson.loads(json_reply)
+        self.print_programme(actprogramme)
+
+    def get_act_programme(self):
+        json_reply = self.send_and_wait_redis("aura", "get_act_programme", RedisChannel.GAP_REPLY)
+        actprogramme = simplejson.loads(json_reply)
+        self.print_programme(actprogramme)
+
+    def print_programme(self, programme):
+        for entry in programme:
+            #print(entry)
+            #self.stringreply += entry._asdict()
+            #print(entry)
+            self.stringreply += "idx: " + str(entry["programme_index"]) + \
+                " --- schedule id #" + str(entry["schedule_id"]) + "." + str(entry["entry_num"]) + \
+                " - show: " + entry["schedule"]["show_name"] + \
+                " - starts @ " + entry["entry_start"] + \
+                " - plays " + str(entry["source"]) + "\n"
+
+    def init_player(self):
+        self.stringreply = self.send_and_wait_redis("aura", "init_player", RedisChannel.IP_REPLY)
+
+    def redis_message(self, channel, message):
+        self.send_redis(channel, message)
+        self.stringreply = "Message '"+message+"' sent to channel '"+channel+"'"
+
+    def swap_playlist_entries(self, from_index, to_index):
+        json_reply = self.send_and_wait_redis("aura", "swap_playlist_entries " + str(from_index) + " " + str(to_index), RedisChannel.MPE_REPLY)
+        actprogramme = simplejson.loads(json_reply)
+        self.print_programme(actprogramme)
+
+    def delete_playlist_entry(self, index):
+        json_reply = self.send_and_wait_redis("aura", "delete_playlist_entry " + str(index), RedisChannel.DPE_REPLY)
+        actprogramme = simplejson.loads(json_reply)
+        self.print_programme(actprogramme)
+
+    def insert_playlist_entry(self, fromtime, source):
+        json_reply = self.send_and_wait_redis("aura", "insert_playlist_entry " + fromtime + " " + source, RedisChannel.IPE_REPLY)
+        actprogramme = simplejson.loads(json_reply)
+        self.print_programme(actprogramme)
+
+    def print_message_queue(self):
+        self.stringreply = self.send_and_wait_redis("aura", "print_message_queue", RedisChannel.PMQ_REPLY)
+
+    # LIQUIDSOAP #
+    def select_mixer(self, mixername, activate=True):
+        # init lqs
+        self.init_liquidsoap_communication()
+
+        # select mixer and return the feedback
+        self.stringreply = self.lsc.channel_activate(mixername, activate)
+
+        # disable connection
+        self.destroy_liquidsoap_communication()
+
+    def set_volume(self, mixernumber, volume):
+        # init lqs and enable comm
+        self.init_liquidsoap_communication()
+        self.stringreply = self.lsc.set_volume(mixernumber, volume)
+        # disable connection
+        self.destroy_liquidsoap_communication()
+
+    def get_active_mixer(self):
+        self.init_liquidsoap_communication()
+        am = self.lsc.get_active_mixer()
+
+        if len(am) == 0:
+            self.destroy_liquidsoap_communication()
+            raise Exception("Guru recognized a problem: No active source!!!")
+
+        self.stringreply = str(am)
+
+        # disable connection
+        self.destroy_liquidsoap_communication()
+
+    def get_mixer_status(self):
+        self.init_liquidsoap_communication()
+
+        status = self.lsc.get_mixer_status()
+
+        for k, v in status.items():
+            self.stringreply += "source: " + k + "\t status: " + v + "\n"
+
+        # disable connection
+        self.destroy_liquidsoap_communication()
+
+    # REDIS #
+    def get_next_file(self, type):
+        redis = RedisMessenger()
+
+        next_file = redis.get_next_file_for(type)
+        # "annotate:file_id='3541',length='400.0',title='Titel',artist='Artist',album='Album',canal='reggae':" +
+        #print(next_file)
+        if next_file == "":
+            next_file = "/var/audio/blank.flac"
+
+        #print("stringreply: "+next_file)
+        self.stringreply = next_file
+
+        self.send_redis("aura", "set_next_file " + type)
+
+    def set_next_file(self, type, file):
+        from modules.communication.redis.messenger import RedisMessenger
+        redis = RedisMessenger()
+
+        redis.set_next_file_for(type, file)
+        self.stringreply = "Set "+file+" for fallback '"+type+"'"

modules/communication/liquidsoap/client.py

+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+import os
+import sys
+import time
+import socket
+import urllib.parse
+import configparser
+import logging
+
+from io import StringIO
+from multiprocessing import Lock
+
+from libraries.exceptions.auraexceptions import LQConnectionError
+
+
+""" LiquidSoapClient Class 
+    Repräsentiert alle Kommandos, die Soundserver und Recorder kennen
+"""
+
+
+class LiquidSoapClient:
+    mutex = None
+    logger = None
+    debug = False
+    socket_path = ""
+
+    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:
+            self.can_connect = False
+            self.connected = False
+            raise e
+        else:
+            self.can_connect = True
+            self.connected = True
+            return True
+
+    # ------------------------------------------------------------------------------------------ #
+    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(str(e))
+            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:
+                self.logger.info("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())
+
+                self.logger.debug("LiquidSoapClient waiting for reply from LiquidSoap Server")
+
+                # wait for reply
+                self.read()
+
+                self.logger.info("LiquidSoapClient got reply: " + self.message)
+            except Exception as e:
+                self.logger.error("Unexpected error: " + str(e))
+                raise
+
+            return self.message
+        else:
+            raise LQConnectionError("LiquidSoapClient not connected to LiquidSoap Server")
+
+    # ------------------------------------------------------------------------------------------ #
+    def simplecommand(self, command):
+        """
+        Parameterloses Kommando ohne Namespace senden
+        @type    command:   string
+        @param   command:   Kommando
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+
+        if self.connected:
+            message = str(command) + '\n'
+            self.socket.sendall(message.decode("UTF-8"))
+            self.read()
+            # self.client.close()
+            return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def get_metadata(self, rid):
+        """
+        Parameterloses Kommando ohne Namespace senden
+        @type    rid:   string/int
+        @param   rid:   Die ID eines Requests
+        @rtype:  dict
+        @return: Die Metadaten als dict
+        """
+        meta = self.command('metadata ' + str(rid), 'request')
+
+        meta = '[root]\n' + meta
+        try:
+            self.metareader.read_string(meta)
+        except configparser.ParsingError as e:
+            self.logger.error("ParsingError. Reason: " + str(e))
+            return False
+        return self.metareader
+
+    # ------------------------------------------------------------------------------------------ #
+    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
\ No newline at end of file

modules/communication/liquidsoap/initthread.py

+import time
+import logging
+import threading
+
+from libraries.enum.scheduleentrytype import ScheduleEntryType
+
+
+class LiquidSoapInitThread(threading.Thread):
+    logger = None
+    socket = None
+    active_entry = None
+    liquidsoapcommunicator = None
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.logger = logging.getLogger("AuraEngine")
+
+    def run(self):
+        try:
+            # sleep needed, because the socket is created to slow by liquidsoap
+            time.sleep(2)
+            self.logger.info("Waited 2s for liquidsoap. Jez soit a si gspian")
+
+            # enable lqs transaction
+            self.liquidsoapcommunicator.enable_transaction()
+
+            # reset channels and reload them
+            self.liquidsoapcommunicator.channels = None
+            channels = self.liquidsoapcommunicator.get_all_channels()
+
+            # set every volume to 0
+            for c in channels:
+                self.liquidsoapcommunicator.channel_volume(c, "0")
+
+            self.liquidsoapcommunicator.playlist_push(self.liquidsoapcommunicator.config.get("install_dir")+"/configuration/blank.flac")
+            self.liquidsoapcommunicator.set_http_url("http://stream.fro.at/fro-128.ogg")
+
+            # select all channels
+            for c in channels:
+                self.liquidsoapcommunicator.channel_activate(c, True)
+
+            time.sleep(2)
+
+            self.logger.info("LiquidSoapInitThread sets activechannel: "+str(self.active_entry))
+
+            channel = self.active_entry.type
+            if channel != "" and channel is not None:
+                self.liquidsoapcommunicator.http_start_stop(channel == ScheduleEntryType.STREAM)
+                self.liquidsoapcommunicator.channel_volume(channel.value, self.active_entry.volume)
+
+            self.liquidsoapcommunicator.disable_transaction()
+        except Exception as e:
+            self.logger.critical("Liquidsoap connection ERROR! Restart LQ Server! Reason: "+str(e))
+
+

modules/communication/liquidsoap/playerclient.py

+from modules.communication.liquidsoap.client import LiquidSoapClient
+
+
+class LiquidSoapPlayerClient(LiquidSoapClient):
+
+    # ------------------------------------------------------------------------------------------ #
+    def mixer(self, command, *args):
+        if command == "status":
+            return self.mixerstatus(*args)
+
+        if command == "inputs":
+            return self.mixerinputs()
+
+        if command == "volume":
+            return self.mixervolume(*args)
+
+        if command == "select":
+            if len(args) == 2:
+                return self.mixerselect(args[0], args[1])
+
+        return "LiquidSoapPlayerClient does not understand mixer."+command+str(args)
+
+    # ------------------------------------------------------------------------------------------ #
+    def http(self, command, *args):
+        if command == "url":
+            return self.set_http_url(*args)
+
+        return "LiquidSoapPlayerClient does not understand http." + command + str(args)
+
+    # ------------------------------------------------------------------------------------------ #
+    def fs(self, command, *args):
+        if command == "push":
+            return self.fs_push(*args)
+
+        return "LiquidSoapPlayerClient does not understand fs." + command + str(args)
+
+    # ------------------------------------------------------------------------------------------ #
+    def fs_push(self, uri):
+        self.command('fs', 'push', uri)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def set_http_url(self, uri):
+        self.command('http', 'url', uri)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def mixerinputs(self):
+        """
+        List all channels on the mixer
+        @type    namespace: string
+        @param   namespace: lqs namespace
+        @rtype:  list
+        @return: answer of our lqs server
+        """
+
+        #        self.logger.info("listchannels modules/controller/liquidsoap.py")
+
+        # send command
+        self.command("mixer", "inputs")
+
+        # convert to list and return it
+        return self.message.strip().split(' ')
+
+
+    # ------------------------------------------------------------------------------------------ #
+    def mixerstatus(self, pos=""):
+        """
+        Get state of a source in the mixer
+        @type    pos:       string
+        @param   pos:       Mixerposition
+        @rtype:  string
+        @return: Response from LiquidSoap
+        """
+        self.command("mixer", "status", str(pos))
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def mixerselect(self, pos, activate):
+        """
+        Kanal/Source aktivieren
+        @type    pos:       string
+        @param   pos:       Die Position
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command("mixer", "select", str(pos) + " " + str(activate).lower())
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def mixervolume(self, pos, volume):
+        """
+        set channel volume
+        :param pos:
+        :param volume:
+        :return:
+        """
+        self.command("mixer", "volume", str(pos) + " " + str(volume))
+        return self.message
+
+# ------------------------------------------------------------------------------------------ #
+    def skip(self, namespace="playlist", pos=""):
+        """
+        Source skippen
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @type    pos:       string
+        @param   pos:       Die Position - optional - Position des Channels vom Mixer benötigt
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('skip', namespace, pos)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def remove(self, pos, namespace="playlist"):
+        """
+        Track  aus der secondary_queue oder der Playlist entfernen
+        @type    pos:       string
+        @param   pos:       Die Position
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('remove', namespace, str(pos))
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def insert(self, uri, pos='0', namespace="playlist"):
+        """
+        Track  einfügen
+        @type    uri:       string
+        @param   uri:       Uri einer Audiodatei
+        @type    pos:       string
+        @param   pos:       Die Position
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('insert', namespace, str(pos) + ' ' + uri)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def move(self, fromPos, toPos, namespace="playlist"):
+        """
+        Track  von Position fromPos nach Position toPos verschieben
+        @type    fromPos:   string/int
+        @param   fromPos:   Position des zu verschiebenden Tracks
+        @type    toPos:     string
+        @param   toPos:     Die Position zu der verschoben werden soll
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('move', namespace, str(fromPos) + ' ' + str(toPos))
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def play(self, namespace="playlist"):
+        """
+        Source abspielen - funktioniert nur bei Playlist
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('play', namespace)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def pause(self, namespace="playlist"):
+        """
+        Source pausieren/stoppen - funktioniert nur bei Playlist
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('pause', namespace)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def flush(self, namespace="playlist"):
+        """
+        Playlist leeren
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('flush', namespace)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def playlistData(self):
+        """
+        Metadaten der Playlist ausgeben
+        @rtype:  string
+        @return: Ein Json-String
+        """
+        self.command('data', 'playlist')
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def seek(self, duration, namespace="playlist"):
+        """
+        Aktuell laufenen Track des Kanals vorspulen
+        @type    duration:  string/int
+        @param   duration:  Dauer in Sekunden
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('seek', namespace, str(duration))
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def get_queue(self, namespace="ch1", queue='queue'):
+        """
+        Queue eines Kanals ausgeben
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @type    queue:     string
+        @param   queue:    Name des queues (queue, primary_queue, secondary_queue)
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command(queue, namespace)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def loadPlaylist(self, uri, params="", namespace="playlist"):
+        """
+        Playlist laden
+        @type    uri:       string
+        @param   uri:       Uri einer Playlist im XSPF-Format
+        @type    params:    string
+        @param   params:    obsolete
+        @type    namespace: string
+        @param   namespace: Namespace der Source - hier nur playlist
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('load', namespace, uri + params)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def currentTrack(self, namespace="request"):
+        """
+        Das oder die ID(s) der gerade abgespielten requests erhalten
+        @type    namespace: string
+        @param   namespace: Namespace der Source
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers (als String)
+        """
+        self.command('on_air', namespace)
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def volume(self, pos, volume, namespace="mixer"):
+        """
+        Lautstärke eines Kanals setzen
+        @type    pos:       int/string
+        @param   pos:       Die Position/ Nummer des Kanals (playlist=0)
+        @type    volume:    int/string
+        @param   volume:    Zahl von 1 -100
+        @type    namespace: string
+        @param   namespace: Namespace der Source (immer mixer)
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('volume', namespace, str(pos) + ' ' + str(volume))
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def playlist_remaining(self):
+        """
+        Wie lange läuft der aktuelle Track der Playlist noch
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('remaining', 'playlist')
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def list_channels(self):
+        """
+        Channels auflisten (Simple JSON)
+        """
+        # Liquidsoap Kommando
+
+        channels = self.sendLqcCommand(self.lqc, 'mixer', 'inputs')
+
+        if not isinstance(channels, list):
+            self.error('02')
+        elif len(channels) < 1:
+            self.warning('01')
+        else:
+            self.success('00', channels)
+
+        self.notifyClient()
\ No newline at end of file

modules/communication/liquidsoap/recorderclient.py

+from modules.communication.liquidsoap.client import LiquidSoapClient
+
+class LiquidSoapRecorderClient(LiquidSoapClient):
+    # ------------------------------------------------------------------------------------------ #
+    def recorder_setfilename(self, filename):
+        """
+        Dateinamen für Aufnahme (Vorproduktion) definieren
+        @type    filename: string
+        @param   filename: Dateiname - Angabe ohne Verzeichnis und mit Extension
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('setfilename', 'record', str(filename))
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def stop_record(self):
+        """
+        Recorder stoppen
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        message = self.command('stop', 'record')
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def start_record(self):
+        """
+        Recorder starten
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('start', 'record')
+        return self.message
+
+    # ------------------------------------------------------------------------------------------ #
+    def recorder_data(self):
+        """
+        Daten des recorders erhalten
+        @rtype:  string
+        @return: Die Antwort des Liquidsoap-Servers
+        """
+        self.command('curfile', 'record')
+        return self.message
\ No newline at end of file

modules/communication/mail/mail.py

+__author__ = 'michel'
+
+import os
+
+
+class AuraMailer():
+
+    def __init__(self, admin_mails, from_mail):
+        self.admin_mails = admin_mails
+        self.from_mail = from_mail
+
+    def send_admin_mail(self, subject, body):
+        admin_mails = self.admin_mails.split()
+
+        for mail_to in admin_mails:
+            self.__send(mail_to, subject, body)
+
+    def __send(self, mail_to, subject, body):
+        sendmail_location = "/usr/sbin/sendmail"
+        p = os.popen("%s -t" % sendmail_location, "w")
+        p.write("From: %s\n" % self.from_mail)
+        p.write("To: %s\n" % mail_to)
+        p.write("Subject: " + subject + "\n")
+        p.write("\n") # blank line separating headers from body
+        p.write(body)
+        status = p.close()
+        return status

modules/communication/redis/adapter.py

+import sys
+import time
+import redis
+import threading
+
+from datetime import datetime
+from threading import Event
+
+from modules.communication.redis.messenger import RedisMessenger
+from libraries.database.statestore import RedisStateStore
+from libraries.exceptions.auraexceptions import RedisConnectionException
+from libraries.enum.consolecolor import TerminalColors
+from libraries.enum.redischannel import RedisChannel
+
+
+class ServerRedisAdapter(threading.Thread, RedisMessenger):
+    debug = False
+    pubsub = None
+    config = None
+    redisdb = None
+    channel = ""
+#    auracontroller = None
+    redisclient = None
+    scheduler = None
+    liquidsoapcommunicator = None
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+        RedisMessenger.__init__(self)
+
+        # init
+        threading.Thread.__init__ (self)
+        self.shutdown_event = Event()
+
+        self.channel = RedisChannel.STANDARD.value
+        self.section = ''
+        self.rstore = RedisStateStore()
+        self.errnr = '00'
+        self.components = {'controller':'01', 'scheduling':'02', 'playd':'03', 'recorder':'04', 'helpers':'09'}
+        self.fromMail = ''
+        self.adminMails = ''
+
+        self.redisclient = ClientRedisAdapter()
+
+    # ------------------------------------------------------------------------------------------ #
+    def run(self):
+        self.redisdb = redis.Redis()
+        self.pubsub = self.redisdb.pubsub()
+        self.pubsub.subscribe(self.channel)
+
+        self.logger.info(TerminalColors.ORANGE.value + "waiting for REDIS message on channel " + self.channel + TerminalColors.ENDC.value)
+
+        for item in self.pubsub.listen():
+            if item["type"] == "subscribe":
+                continue
+
+            self.logger.info(TerminalColors.ORANGE.value + "received REDIS message: " + TerminalColors.ENDC.value + str(item))
+
+            item["channel"] = self.decode_if_needed(item["channel"])
+            item["data"] = self.decode_if_needed(item["data"])
+
+            try:
+                self.work(item)
+            except RedisConnectionException as rce:
+                self.logger.error(rce)
+
+            self.logger.info(TerminalColors.ORANGE.value + "waiting for REDIS message on channel " + self.channel + TerminalColors.ENDC.value)
+
+        self.pubsub.unsubscribe()
+        self.logger.error("unsubscribed from " + self.channel + " and finished")
+
+    # ------------------------------------------------------------------------------------------ #
+    def decode_if_needed(self, val):
+        if isinstance(val, bytes):
+            return val.decode("utf-8")
+        return val
+
+    # ------------------------------------------------------------------------------------------ #
+    def listen_for_one_message(self, channel, socket_timeout=2):
+        self.redisdb = redis.Redis(socket_timeout=socket_timeout)
+        self.pubsub = self.redisdb.pubsub()
+        self.pubsub.subscribe(channel)
+
+        try:
+            self.logger.info("I am listening on channel '"+channel+"' for "+str(socket_timeout)+" seconds")
+
+            for item in self.pubsub.listen():
+                it = self.receive_message(item)
+                if it is not None:
+                    break
+        except redis.exceptions.TimeoutError as te:
+            raise te
+
+        return item["data"]
+
+    # ------------------------------------------------------------------------------------------ #
+    def receive_message(self, item):
+        if item["type"] == "subscribe":
+            self.logger.info("i am subscribed to channel " + item["channel"].decode("utf-8"))
+            return None
+
+        item["channel"] = item["channel"].decode("utf-8")
+        if isinstance(item["data"], bytes):
+            item["data"] = item["data"].decode("utf-8")
+
+        self.pubsub.unsubscribe()
+        return item
+
+    # ------------------------------------------------------------------------------------------ #
+    def work(self, item):
+        if item["data"] == "fetch_new_programme":
+            self.execute(RedisChannel.FNP_REPLY.value, self.scheduler.fetch_new_programme, )
+
+        elif item["data"] == "init_player":
+            self.execute(RedisChannel.IP_REPLY.value, self.liquidsoapcommunicator.init_player)
+
+        elif item["data"] == "get_act_programme":
+            self.execute(RedisChannel.GAP_REPLY.value, self.scheduler.get_act_programme_as_string)
+
+        elif item["data"] == "print_message_queue":
+            self.execute(RedisChannel.PMQ_REPLY.value, self.scheduler.print_message_queue)
+
+        elif item["data"].find("swap_playlist_entries") >= 0:
+            extracted = item["data"].split()[1:3]
+            param = {"from_index": extracted[0], "to_index": extracted[1]}
+            self.execute(RedisChannel.MPE_REPLY.value, self.scheduler.swap_playlist_entries, param)
+
+        elif item["data"].find("delete_playlist_entry") >= 0:
+            entrynum = item["data"].split()[1]
+            self.logger.info("entry to del: " + str(entrynum))
+            self.execute(RedisChannel.DPE_REPLY.value, self.scheduler.delete_playlist_entry, entrynum)
+
+        elif item["data"].find("insert_playlist_entry") >= 0:
+            extracted = item["data"].split()[1:3]
+            param = {"fromtime": extracted[0], "source": extracted[1]}
+            self.execute(RedisChannel.IPE_REPLY.value, self.scheduler.insert_playlist_entry, param)
+
+        elif item["data"].find("set_next_file") >= 0:
+            playlist = item["data"].split()[1]
+            playlist = playlist[0:len(playlist)-9]
+            self.logger.critical("HAVE TO SET NEXT FILE FOR: "+playlist)
+            self.execute(RedisChannel.SNF_REPLY.value, self.scheduler.set_next_file_for, playlist)
+
+        else:
+            raise RedisConnectionException("ServerRedisAdapter Cannot understand command: " + item["data"])
+
+    # ------------------------------------------------------------------------------------------ #
+    def execute(self, channel, f, param=None):
+        if param:
+            reply = f(param)
+        else:
+            reply = f()
+
+        if reply is None:
+            reply = ""
+
+        # sometimes the sender is faster than the receiver. redis messages would be lost
+        time.sleep(0.1)
+
+        self.logger.info(TerminalColors.ORANGE.value + "replying " + reply + " on channel " + channel + TerminalColors.ENDC.value)
+
+        # publish
+        self.redisclient.publish(channel, reply)
+
+    # ------------------------------------------------------------------------------------------ #
+    def join_comm(self):
+        try:
+            while self.is_alive():
+                self.logger.info(str(datetime.now())+" joining")
+                self.join()
+                self.logger.warning("join out")
+
+        except (KeyboardInterrupt, SystemExit):
+            # Dem Server den Shutdown event setzen
+            # server.shutdown_event.set()
+            # Der Server wartet auf Eingabe
+            # Daher einen Client initiieren, der eine Nachricht schickt
+            self.halt()
+            sys.exit('Terminated')
+
+    # ------------------------------------------------------------------------------------------ #
+    def halt(self):
+        """
+        Stop the server
+        """
+        if self.shutdown_event.is_set():
+            return
+        try:
+            del self.auracontroller
+        except:
+            pass
+        self.shutdown_event.set()
+        result = 'failed'
+        try:
+            result = self.socket.unbind("tcp://"+self.ip+":"+self.port)
+        except:
+            pass
+
+        #self.socket.close()
+
+    # ------------------------------------------------------------------------------------------ #
+    def send(self, message):
+        """
+        Send a message to the client
+        :param message: string
+        """
+        if not self.can_send:
+            self.logger.info("sending a "+str(len(message))+" long message via REDIS.")
+            self.socket.send(message.encode("utf-8"))
+            self.can_send = False
+        else:
+            self.logger.warning("cannot send message via REDIS: "+str(message))
+
+class ClientRedisAdapter(RedisMessenger):
+
+    def __init__(self):
+        RedisMessenger.__init__(self)
+
+    # ------------------------------------------------------------------------------------------ #
+    def publish(self, channel, message):
+        if type(channel) == RedisChannel:
+            channel = channel.value
+
+        self.rstore.publish(channel, message)

modules/communication/redis/messenger.py

+# -*- coding: utf-8 -*-
+import time
+import logging
+import datetime
+
+from libraries.database.statestore import RedisStateStore
+from modules.communication.mail.mail import AuraMailer
+from libraries.exceptions.auraexceptions import PlaylistException
+from libraries.enum.redischannel import RedisChannel
+
+"""
+Meldungen an den StateStore schicken
+"""
+
+
+class RedisMessenger():
+    logger = None
+    rstore = None
+
+    def __init__(self):
+        """
+            Constructor
+        """
+        self.logger = logging.getLogger("AuraEngine")
+        self.channel = RedisChannel.STANDARD
+        self.section = ''
+        self.rstore = RedisStateStore()
+        self.errnr = '00'
+        self.components = {'controller':'01', 'scheduling':'02', 'playd':'03', 'recorder':'04', 'helpers':'09'}
+        self.fromMail = ''
+        self.adminMails = ''
+
+    # ------------------------------------------------------------------------------------------ #
+    def set_channel(self, channel):
+        """
+        Einen "Kanal" setzen - zb scheduling
+        @type channel: string
+        @param channel: Kanal/Name der Komponente
+        """
+        self.channel = channel
+        if channel in self.components:
+            self.errnr = self.components[channel]
+        self.rstore.set_channel(channel)
+
+    # ------------------------------------------------------------------------------------------ #
+    def set_section(self, section):
+        """
+        Einen Sektion / Gültigkeitsbereich der Meldung setzen - zb internal
+        @type section: string
+        @param section: Gültigkeitsbereich
+        """
+        self.section = section
+
+
+# ------------------------------------------------------------------------------------------ #
+    def set_mail_addresses(self, fromMail, adminMails):
+        """
+        Einen Sektion / Gültigkeitsbereich der Meldung setzen - zb internal
+        @type section: string
+        @param section: Gültigkeitsbereich
+        """
+        self.fromMail = fromMail
+        self.adminMails = adminMails
+
+    # ------------------------------------------------------------------------------------------ #
+    def send(self, message, code, level, job, value='', section=''):
+        """
+        Eine Message senden
+        @type message:  string
+        @param message: menschenverständliche Nachricht
+        @type code:     string
+        @param code:    Fehlercode - endet mit 00 bei Erfolg
+        @type level:    string
+        @param level:   Error-Level - info, warning, error, fatal
+        @type job:      string
+        @param job:     Name der ausgeführten Funktion
+        @type value:    string
+        @param value:   Ein Wert
+        @type section:  string
+        @param section: Globale Sektion überschreiben
+        """
+        section = self.section if section == '' else section
+        self.time = str(datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S:%f'))
+        self.utime = time.time()
+        state = {'message':message.strip().replace("'","\\'"), 'code':self.errnr + str(code),'job':job,'value':value}
+        self.rstore.set_section(section)
+        self.rstore.store(level, state)
+
+        # TODO: hier kann auch was zu redis gepostet werden
+        if level == 'info' or level == 'success':
+            self.logger.info(message)
+        elif level == 'warning':
+            self.logger.warning(message)
+        elif level == 'error':
+            self.logger.error(message)
+            self.send_admin_mail(level, message, state)
+
+        elif level == 'fatal':
+            self.logger.critical(message)
+            self.send_admin_mail(level, message, state)
+
+    # ------------------------------------------------------------------------------------------ #
+    def say_alive(self):
+        """
+        Soll alle 20 Sekunden von den Komponenten ausgeführt werden,
+        um zu melden, dass sie am Leben sind
+        """
+        self.rstore.set_alive_state()
+
+    # ------------------------------------------------------------------------------------------ #
+    def get_alive_state(self, channel):
+        """
+        Live State abfragen
+        @type channel: string
+        @param channel: Channel/Komponente
+        """
+        return self.rstore.get_alive_state(channel)
+
+    # ------------------------------------------------------------------------------------------ #
+    def set_state(self, name, value, expires=None, channel=None):
+        """
+        Kündigt einen Event an
+        @type name: string
+        @param name: Name des state
+        @type value: string
+        @param value: Wert
+        @type channel: string
+        @param channel: Kanal (optional)
+        """
+        if not channel:
+            channel = self.channel
+
+        self.rstore.set_state(name, value, expires, channel)
+
+    # ------------------------------------------------------------------------------------------ #
+    def queue_add_event(self, name, eventtime, value, channel=None):
+        """
+        Kündigt einen Event an
+        @type name: string
+        @param name: der Name des Events
+        @type eventtime: string|datetime.datetime
+        @param eventtime: Datum und Zeit des events
+        @type value: dict
+        @param value: Werte
+        @type channel: string
+        @param channel: Kanal (optional)
+        """
+        if not channel:
+            channel = self.channel
+
+        if type(eventtime) == type(str()):
+            eventtime_str = datetime.datetime.strptime(eventtime[0:16].replace(' ','T'), "%Y-%m-%dT%H:%M").strftime("%Y-%m-%dT%H:%M")
+
+        elif type(eventtime) is datetime.datetime:
+            eventtime_str = eventtime.strftime("%Y-%m-%dT%H:%M")
+
+        else:
+            raise TypeError('eventtime must be a datetime.date or a string, not a %s' % type(eventtime))
+
+        self.rstore.queue_add_event(eventtime_str, name, value, channel)
+
+    # ------------------------------------------------------------------------------------------ #
+    def queue_remove_events(self, name, channel=None):
+        """
+        Löscht Events
+        @type name: string
+        @param name: der Name des Events
+        @type channel: string
+        @param channel: Kanal (optional)
+        """
+        if not channel:
+            channel = self.channel
+
+        self.rstore.queue_remove_events(name, channel)
+
+    # ------------------------------------------------------------------------------------------ #
+    def fire_event(self, name, value, channel=None):
+        """
+        Feuert einen Event
+        @type name: string
+        @param name: der Name des Events
+        @type value: dict
+        @param value: Werte
+        @type channel: string
+        @param channel: Kanal (optional)
+        """
+        if not channel:
+            channel = self.channel
+
+        self.rstore.fire_event(name, value, channel)
+
+    # ------------------------------------------------------------------------------------------ #
+    def get_event_queue(self, name=None, channel=None):
+        """
+        Holt events eines Kanals
+        @type channel: string
+        @param channel: Kanal (optional)
+        @rtype: list
+        @return: Liste der Events
+        """
+        queue = self.rstore.get_event_queue(name, channel)
+        return queue
+
+    # ------------------------------------------------------------------------------------------ #
+    def get_events(self, name=None, channel=None):
+        """
+        Holt events eines Kanals
+        @type channel: string
+        @param channel: Kanal (optional)
+        @rtype: list
+        @return: Liste der Events
+        """
+        events = self.rstore.get_events(name, channel)
+        return events
+
+    # ------------------------------------------------------------------------------------------ #
+    def get_event(self, name=None, channel=None):
+        """
+        Holt event eines Kanals
+        @type channel: string
+        @param channel: Kanal (optional)
+        @rtype: dict
+        @return: Event
+        """
+        events = self.rstore.get_events(name, channel)
+        result = False
+        if events:
+            result = events.pop(0)
+        return result
+
+    # ------------------------------------------------------------------------------------------ #
+    def send_admin_mail(self, level, message, state):
+        """
+        Sendent mail an Admin(s),
+        @type message: string
+        @param message: Die Message
+        @type state: dict
+        @param state: Der State
+        @return result
+        """
+
+        if self.fromMail and self.adminMails:
+            subject = "Possible comba problem on job " + state['job'] + " - " + level
+            mailmessage = "Hi Admin,\n comba reports a possible problem\n\n"
+            mailmessage = mailmessage + level + "!\n"
+            mailmessage = mailmessage + message + "\n\n"
+            mailmessage = mailmessage + "Additional information:\n"
+            mailmessage = mailmessage + "##################################################\n"
+            mailmessage = mailmessage + "Job:\t" + state['job'] + "\n"
+            mailmessage = mailmessage + "Code:\t" + state['code'] + "\n"
+            mailmessage = mailmessage + "Value:\t" + str(state['value']) + "\n"
+            mailer = AuraMailer(self.adminMails, self.fromMail)
+            mailer.send_admin_mail(subject, mailmessage)
+        else:
+            return False
+
+    # ------------------------------------------------------------------------------------------ #
+    def receive(self):
+        """
+        Bisher wird nichts empfangen
+        """
+        return ""
+
+    # ------------------------------------------------------------------------------------------ #
+    def get_next_file_for(self, playlisttype):
+        next = self.rstore.db.get('next_'+playlisttype+'_file')
+
+        if next is None:
+            return ""
+
+        return next.decode('utf-8')
+
+    # ------------------------------------------------------------------------------------------ #
+    def set_next_file_for(self, playlisttype, file):
+        self.rstore.db.set("next_" + playlisttype + "file", file)
+
+

modules/liquidsoap/__init__.py

+__author__ = 'michel'

modules/liquidsoap/alsa_settings_tester.liq

+set("log.file.path", "./<script>.log")
+
+set("server.telnet", true)
+set("server.telnet.bind_addr", "0.0.0.0")
+set("server.telnet.port", 1234)
+
+# ALSA / pulse settings
+# durch ausprobieren herausgefunden für asus xonar dgx 5.1
+# chip: CMI8788
+# driver: snd_oxygen
+
+set("frame.duration", 0.30)
+set("alsa.alsa_buffer", 8192) # 7168) # 6144) # 8192) # 10240) #15876
+set("alsa.buffer_length", 25)
+set("alsa.periods", 0) # assertion error when setting periods other than 0 => alsa default
+
+input_linein = input.alsa(id="linein", bufferize = false)
+input_fs = single(id="fs", "/var/audio/fallback/output.flac")
+input_http = input.http(id="http", "http://stream.fro.at/fro-128.ogg")
+
+mixer = mix(id="mixer", [input_fs, input_http, input_linein])
+
+output.alsa(id="lineout", bufferize = false, mixer)
+

modules/liquidsoap/fallback.liq

+# Custom crossfade to deal with jingles.
+def smart_crossfade (~start_next=5.,~fade_in=3.,~fade_out=3.,
+                     ~default=(fun (a,b) -> sequence([a, b])),
+                     ~high=-15., ~medium=-32., ~margin=4.,
+                     ~width=2.,~conservative=false,s)
+  fade.out = fade.out(type="sin",duration=fade_out)
+  fade.in  = fade.in(type="sin",duration=fade_in)
+  add = fun (a,b) -> add(normalize=false,[b, a])
+  log = log(label="smart_crossfade")
+
+  def transition(a,b,ma,mb,sa,sb)
+
+    list.iter(fun(x)-> log(level=4,"Before: #{x}"),ma)
+    list.iter(fun(x)-> log(level=4,"After : #{x}"),mb)
+
+    if ma["type"] == "jingles" or mb["type"] == "jingles" then
+      log("Old or new file is a jingle: sequenced transition.")
+      sequence([sa, sb])
+    elsif
+      # If A and B are not too loud and close, fully cross-fade them.
+      a <= medium and b <= medium and abs(a - b) <= margin
+    then
+      log("Old <= medium, new <= medium and |old-new| <= margin.")
+      log("Old and new source are not too loud and close.")
+      log("Transition: crossed, fade-in, fade-out.")
+      add(fade.out(sa),fade.in(sb))
+
+    elsif
+      # If B is significantly louder than A, only fade-out A.
+      # We don't want to fade almost silent things, ask for >medium.
+      b >= a + margin and a >= medium and b <= high
+    then
+      log("new >= old + margin, old >= medium and new <= high.")
+      log("New source is significantly louder than old one.")
+      log("Transition: crossed, fade-out.")
+      add(fade.out(sa),sb)
+
+    elsif
+      # Opposite as the previous one.
+      a >= b + margin and b >= medium and a <= high
+    then
+      log("old >= new + margin, new >= medium and old <= high")
+      log("Old source is significantly louder than new one.")
+      log("Transition: crossed, fade-in.")
+      add(sa,fade.in(sb))
+
+    elsif
+      # Do not fade if it's already very low.
+      b >= a + margin and a <= medium and b <= high
+    then
+      log("new >= old + margin, old <= medium and new <= high.")
+      log("Do not fade if it's already very low.")
+      log("Transition: crossed, no fade.")
+      add(sa,sb)
+
+    # What to do with a loud end and a quiet beginning ?
+    # A good idea is to use a jingle to separate the two tracks,
+    # but that's another story.
+
+    else
+      # Otherwise, A and B are just too loud to overlap nicely,
+      # or the difference between them is too large and overlapping would
+      # completely mask one of them.
+      log("No transition: using default.")
+      default(sa, sb)
+    end
+  end
+
+  smart_cross(width=width, duration=start_next, conservative=conservative, transition, s)
+end
+
+# create a pool
+def fallback_create(~skip=true, name, requestor)
+  log("Creating channel #{name}")
+
+  # Create the request.dynamic source
+  # Set conservative to true to queue
+  # several songs in advance
+  #source = request.dynamic(conservative=true, length=50., id="pool_"^name, requestor, timeout=60.)
+  source = request.dynamic(length=50., id="pool_"^name, requestor, timeout=60.)
+
+  # Apply normalization using replaygain information
+  source = amplify(1., override="replay_gain", source)
+
+  # Skip blank when asked to
+  source =
+    if skip then
+      skip_blank(source, max_blank=10., threshold=-40.)
+    else
+      source
+    end
+
+  # Tell the system when a new track
+  # is played
+  source = on_metadata(fun (meta) ->
+    system('#{list.assoc("install_dir", ini)}/guru.py -c aura -t liquid_startup'), source)
+
+  # Finally apply a smart crossfading
+  smart_crossfade(source)
+end
+
+def create_dynamic_playlist(next)
+  log("next song is: #{next}")
+  request.create(list.hd(next))
+end
+
+def create_playlist() =
+  log("requesting next song for PLAYLIST")
+  result = get_process_lines('#{list.assoc("install_dir", ini)}/guru.py --get-next-file-for "playlist" --quiet')
+  create_dynamic_playlist(result)
+end
+
+def create_station_fallback() =
+  log("requesting next song for STATION fallback")
+  result = get_process_lines('#{list.assoc("install_dir", ini)}/guru.py --get-next-file-for "station-fallback" --quiet')
+  create_dynamic_playlist(result)
+end
+
+def create_show_fallback() =
+  log("requesting next song for SHOW fallback")
+  result = get_process_lines('#{list.assoc("install_dir", ini)}/guru.py --get-next-file-for "show-fallback" --quiet')
+  create_dynamic_playlist(result)
+end
+
+def create_timeslot_fallback() =
+  log("requesting next song for TIMESLOT fallback")
+  result = get_process_lines('#{list.assoc("install_dir", ini)}/guru.py --get-next-file-for "timeslot-fallback" --quiet')
+  create_dynamic_playlist(result)
+end
\ No newline at end of file

modules/liquidsoap/helpers/__init__.py

+__author__ = 'michel'
+
+import os
+import sys

modules/liquidsoap/helpers/silence.sh

+#!/bin/bash
+
+pack_int(){ printf "%08X\n" $1 | sed 's/\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)/\\\\\\x\4\\\\\\x\3\\\\\\x\2\\\\\\x\1/I' | xargs printf; }
+
+pack_short(){ printf "%04X\n" $1 | sed 's/\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)/\\\\\\x\2\\\\\\x\1/I' | xargs printf; }
+
+duration=1800
+if [[ $# -eq 1 ]]; then
+    duration=$1
+fi
+
+channels=2
+bps=16
+sample=44100
+Subchunk1Size=18
+Subchunk2Size=$(echo "$duration*$sample*$channels*$bps/8" | bc)
+ChunkSize=$((20 + $Subchunk1Size + $Subchunk2Size))
+
+echo -n RIFF
+pack_int $ChunkSize
+echo -n "WAVEfmt "
+pack_int $Subchunk1Size
+pack_short 1
+pack_short $channels
+pack_int $sample
+pack_int $((bps/8 * channels * sample))
+pack_short $((bps/8 * channels))
+pack_short $bps
+pack_short 0
+echo -n data
+pack_int $Subchunk2Size
+
+dd if=/dev/zero bs=1 count=$Subchunk2Size 2>/dev/null

modules/liquidsoap/readini.liq

+
+def read_ini(file)
+    ret = get_process_lines("cat "^file )
+    ret = list.map(string.split(separator="="), ret)
+
+    # l' => the filling list
+    def f(l',l)=
+      if list.length(l) >= 2 then
+        line = string.extract(pattern='"(.*)"', list.nth(l,1))
+        print(line)
+        print((list.hd(l),line['1']))
+        
+        list.append([(list.hd(l),line['1'])],l')
+      else
+        if list.length(l) >= 1 then
+          list.append([(list.hd(l),"")],l')
+        else
+          l'
+        end
+      end
+    end
+
+    list.fold(f,[],ret)
+end

modules/liquidsoap/serverfunctions.liq

+# shutdown server function
+#server.register(namespace='server',
+#    description="shutdown server",
+#    usage="stop",
+#    "stop",
+#    fun(x,y) -> stop_server )
\ No newline at end of file