Commit 109388a0 authored by Gottfried Gaisbauer's avatar Gottfried Gaisbauer
Browse files

added comments, removed unused functions

parent a2896088
......@@ -26,10 +26,8 @@ __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
Aura Config Reader
"""
import os
import sys
......
......@@ -107,6 +107,7 @@ class Padavan:
# 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
......@@ -116,29 +117,35 @@ class Padavan:
# 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 shutdown(self):
self.send_redis("aura", "shutdown")
self.stringreply = "Shutdown message sent!"
# ------------------------------------------------------------------------------------------ #
def fetch_new_programme(self):
json_reply = self.send_and_wait_redis("aura", "fetch_new_programme", RedisChannel.FNP_REPLY)
if json_reply != "":
......@@ -147,16 +154,19 @@ class Padavan:
else:
print("No programme fetched")
# ------------------------------------------------------------------------------------------ #
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 get_connection_status(self):
json_reply = self.send_and_wait_redis("aura", "get_connection_status", RedisChannel.GCS_REPLY)
connection_status = simplejson.loads(json_reply)
self.print_connection_status(connection_status)
# ------------------------------------------------------------------------------------------ #
def print_programme(self, programme):
for entry in programme:
self.stringreply += "idx: " + str(entry["programme_index"]) + \
......@@ -165,6 +175,7 @@ class Padavan:
" - starts @ " + entry["entry_start"] + \
" - plays " + str(entry["source"]) + "\n"
# ------------------------------------------------------------------------------------------ #
def print_connection_status(self, connection_status):
if connection_status["pv"]:
......@@ -197,40 +208,47 @@ class Padavan:
else:
self.stringreply += "\nConnection to redis: " + TerminalColors.RED.value + " " + str(connection_status["redis"]) + TerminalColors.ENDC.value
# ------------------------------------------------------------------------------------------ #
def init_player(self):
self.stringreply = self.send_and_wait_redis("aura", "init_player", RedisChannel.IP_REPLY)
# ------------------------------------------------------------------------------------------ #
def recreatedb(self):
print("YOU WILL GET PROBLEMS DUE TO DATABASE BLOCKING IF aura.py IS RUNNING! NO CHECKS IMPLEMENTED SO FAR!")
x = AuraDatabaseModel()
x.recreate_db()
self.stringreply = "Database recreated!"
# ------------------------------------------------------------------------------------------ #
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()
......@@ -241,6 +259,7 @@ class Padavan:
# disable connection
self.destroy_liquidsoap_communication()
# ------------------------------------------------------------------------------------------ #
def set_volume(self, mixernumber, volume):
# init lqs and enable comm
self.init_liquidsoap_communication()
......@@ -248,6 +267,7 @@ class Padavan:
# disable connection
self.destroy_liquidsoap_communication()
# ------------------------------------------------------------------------------------------ #
def get_active_mixer(self):
self.init_liquidsoap_communication()
am = self.lsc.get_active_mixer()
......@@ -261,6 +281,7 @@ class Padavan:
# disable connection
self.destroy_liquidsoap_communication()
# ------------------------------------------------------------------------------------------ #
def get_mixer_status(self):
self.init_liquidsoap_communication()
......@@ -273,6 +294,8 @@ class Padavan:
self.destroy_liquidsoap_communication()
# REDIS #
# ------------------------------------------------------------------------------------------ #
def get_next_file(self, type):
redis = RedisMessenger()
......@@ -287,6 +310,7 @@ class Padavan:
self.send_redis("aura", "set_next_file " + type)
# ------------------------------------------------------------------------------------------ #
def set_next_file(self, type, file):
from modules.communication.redis.messenger import RedisMessenger
redis = RedisMessenger()
......
......@@ -31,11 +31,14 @@ from libraries.database.broadcasts import ScheduleEntry
from libraries.base.config import AuraConfig
# ------------------------------------------------------------------------------------------ #
class ConnectionTester(AuraConfig):
# ------------------------------------------------------------------------------------------ #
def __init__(self):
super(ConnectionTester, self).__init__()
# ------------------------------------------------------------------------------------------ #
def get_connection_status(self):
status = dict()
status["db"] = self.test_db_conn()
......@@ -47,6 +50,7 @@ class ConnectionTester(AuraConfig):
return simplejson.dumps(status)
# ------------------------------------------------------------------------------------------ #
def test_db_conn(self):
try:
ScheduleEntry.select_all()
......@@ -55,6 +59,7 @@ class ConnectionTester(AuraConfig):
return True
# ------------------------------------------------------------------------------------------ #
def test_lqs_conn(self):
try:
lsc = LiquidSoapCommunicator(self.config)
......@@ -64,6 +69,7 @@ class ConnectionTester(AuraConfig):
except Exception as e:
return False
# ------------------------------------------------------------------------------------------ #
def test_lqsr_conn(self):
try:
lsc = LiquidSoapCommunicator(self.config)
......@@ -73,13 +79,16 @@ class ConnectionTester(AuraConfig):
except Exception as e:
return False
# ------------------------------------------------------------------------------------------ #
def test_pv_conn(self):
return self.test_url_connection(self.config.get("calendarurl"))
# ------------------------------------------------------------------------------------------ #
def test_tank_conn(self):
# test load of playlist 1
return self.test_url_connection(self.config.get("importerurl")+"1")
# ------------------------------------------------------------------------------------------ #
def test_redis_conn(self):
from modules.communication.redis.adapter import ClientRedisAdapter
try:
......
......@@ -221,42 +221,6 @@ class LiquidSoapClient:
self.logger.debug(msg)
raise LQConnectionError(msg)
# ------------------------------------------------------------------------------------------ #
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):
"""
......
......@@ -22,16 +22,12 @@
# along with engine. If not, see <http://www.gnu.org/licenses/>.
#
import os
import time
import codecs
import urllib
import logging
import tempfile
import simplejson
from modules.communication.liquidsoap.playerclient import LiquidSoapPlayerClient
from modules.communication.liquidsoap.recorderclient import LiquidSoapRecorderClient
# from modules.communication.liquidsoap.recorderclient import LiquidSoapRecorderClient
from modules.communication.liquidsoap.initthread import LiquidSoapInitThread
from modules.communication.mail.mail import AuraMailer
......
......@@ -35,10 +35,12 @@ class LiquidSoapInitThread(threading.Thread):
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
......
......@@ -95,23 +95,12 @@ class LiquidSoapPlayerClient(LiquidSoapClient):
# ------------------------------------------------------------------------------------------ #
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=""):
"""
......
#
# engine
#
# Playout Daemon for autoradio project
#
#
# Copyright (C) 2017-2018 Gottfried Gaisbauer <gottfried.gaisbauer@servus.at>
#
# This file is part of engine.
#
# engine 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, either version 3 of the License, or
# any later version.
#
# engine 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 engine. If not, see <http://www.gnu.org/licenses/>.
#
from modules.communication.liquidsoap.client import LiquidSoapClient
class LiquidSoapRecorderClient(LiquidSoapClient):
# ------------------------------------------------------------------------------------------ #
def record(self, command, *args):
if command == "status":
self.command('record', 'status')
return self.message
# ------------------------------------------------------------------------------------------ #
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
......@@ -31,24 +31,28 @@ from libraries.exceptions.auraexceptions import MailingException
class AuraMailer():
config = None
# ------------------------------------------------------------------------------------------ #
def __init__(self, config):
self.config = config
self.admin_mails = config.get("admin_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):
# read config
mail_server = self.config.get("mail_server")
mail_port = self.config.get("mail_server_port")
mail_user = self.config.get("mail_user")
mail_pass = self.config.get("mail_pass")
from_mail = self.config.get("from_mail")
# check settings
if mail_server == "":
raise MailingException("Mail Server not set")
if mail_port == "":
......@@ -60,6 +64,7 @@ class AuraMailer():
if from_mail == "":
raise MailingException("From Mail not set")
# stuff the message together and ...
msg = EmailMessage()
msg.set_content(body)
mailsubject_prefix = self.config.get("mailsubject_prefix")
......@@ -70,18 +75,12 @@ class AuraMailer():
msg["From"] = from_mail
msg["To"] = mail_to
server = smtplib.SMTP(mail_server, int(mail_port))
server.starttls()
server.login(mail_user, mail_pass)
server.send_message(msg)
server.quit()
# 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
# ... send the mail
try:
server = smtplib.SMTP(mail_server, int(mail_port))
server.starttls()
server.login(mail_user, mail_pass)
server.send_message(msg)
server.quit()
except Exception as e:
raise MailingException(str(e))
......@@ -38,6 +38,7 @@ from libraries.exceptions.auraexceptions import RedisConnectionException
from libraries.enum.auraenumerations import RedisChannel, TerminalColors
# ------------------------------------------------------------------------------------------ #
class ServerRedisAdapter(threading.Thread, RedisMessenger):
debug = False
# logger = None
......@@ -50,6 +51,7 @@ class ServerRedisAdapter(threading.Thread, RedisMessenger):
connection_tester = None
liquidsoapcommunicator = None
# ------------------------------------------------------------------------------------------ #
def __init__(self):
#super(ServerRedisAdapter, self).__init__()
threading.Thread.__init__(self)
......@@ -261,6 +263,7 @@ class ServerRedisAdapter(threading.Thread, RedisMessenger):
self.logger.warning("cannot send message via REDIS: "+str(message))
# ------------------------------------------------------------------------------------------ #
class ClientRedisAdapter(RedisMessenger):
def __init__(self):
......
......@@ -37,10 +37,12 @@ Send and receive redis messages
"""
# ------------------------------------------------------------------------------------------ #
class RedisMessenger():
logger = None
rstore = None
# ------------------------------------------------------------------------------------------ #
def __init__(self):
super(RedisMessenger, self).__init__()
"""
......@@ -77,7 +79,7 @@ class RedisMessenger():
self.section = section
# ------------------------------------------------------------------------------------------ #
# ------------------------------------------------------------------------------------------ #
def set_mail_addresses(self, fromMail, adminMails):
"""
Einen Sektion / Gültigkeitsbereich der Meldung setzen - zb internal
......@@ -111,7 +113,6 @@ class RedisMessenger():
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':
......
......@@ -31,6 +31,8 @@ from modules.communication.mail.mail import AuraMailer
from libraries.exceptions.auraexceptions import MailingException
from libraries.exceptions.auraexceptions import DiskSpaceException
# ------------------------------------------------------------------------------------------ #
class DiskSpaceWatcher(threading.Thread):
liquidsoapcommunicator = None
exit_event = None
......@@ -40,6 +42,7 @@ class DiskSpaceWatcher(threading.Thread):
sent_a_mail = False
is_critical = False
# ------------------------------------------------------------------------------------------ #
def __init__(self, config, logger, liquidsoapcommunicator):
self.liquidsoapcommunicator = liquidsoapcommunicator
self.config = config
......@@ -49,6 +52,7 @@ class DiskSpaceWatcher(threading.Thread):
self.exit_event = threading.Event()
# ------------------------------------------------------------------------------------------ #
def run(self):
# set seconds to wait
try:
......@@ -70,9 +74,11 @@ class DiskSpaceWatcher(threading.Thread):
# and wait
self.exit_event.wait(seconds_to_wait)
# ------------------------------------------------------------------------------------------ #
def stop(self):
self.exit_event.set()
# ------------------------------------------------------------------------------------------ #
def check_disk_space(self):
# check disk space where aure engine is writing to
self.check_recorder_disk_space()
......@@ -90,11 +96,13 @@ class DiskSpaceWatcher(threading.Thread):
self.is_critical = False
self.sent_a_mail = False
# ------------------------------------------------------------------------------------------ #
def check_recorder_disk_space(self):
for i in range(5):
if self.config.get("rec_" + str(i)) == "y":
self.check_recorder_num_disk_space(i)
# ------------------------------------------------------------------------------------------ #
def check_recorder_num_disk_space(self, num):
folder = self.config.get("rec_" + str(num) + "_folder")
......@@ -107,12 +115,14 @@ class DiskSpaceWatcher(threading.Thread):
# stop recorder when diskspace is critical
self.liquidsoapcommunicator.recorder_stop(num)
# ------------------------------------------------------------------------------------------ #
def check_logging_disk_space(self):
try:
self.check_disk_space_of_folder(self.config.get("logdir"))
except DiskSpaceException as e:
self.logger.critical(str(e))
# ------------------------------------------------------------------------------------------ #
def check_disk_space_of_folder(self, folder):
warning_value_raw = self.config.get("diskspace_warning_value")
critical_value_raw = self.config.get("diskspace_critical_value")
......@@ -152,6 +162,7 @@ class DiskSpaceWatcher(threading.Thread):
raise DiskSpaceException("Diskspace in " + folder + " reached critical value!")
# ------------------------------------------------------------------------------------------ #
def send_mail(self, subj, msg):
try:
self.logger.info("Trying to send mail with subject " + subj + " and message " + msg + ".")
......@@ -159,6 +170,7 @@ class DiskSpaceWatcher(threading.Thread):
except MailingException as e:
self.logger.critical("Cannot send mail with subject " + subj + " and message " + msg + ". Reason: " + str(e))
# ------------------------------------------------------------------------------------------ #
def parse_diskspace(self, value):
if value.endswith("K") or value.endswith("k"):
return int(value[:-1]) * 1024
......
......@@ -155,6 +155,7 @@ class AuraCalendarService(threading.Thread):
# terminate the thread
return
# ------------------------------------------------------------------------------------------ #
def store_schedule(self, schedule):
schedule_db = Schedule.query.filter(Schedule.schedule_id == schedule["schedule_id"]).first()
havetoadd = False
......@@ -448,14 +449,6 @@ class AuraCalendarService(threading.Thread):
audio_file = FLAC(entry.cleansource)
return audio_file.info.length