326 lines
7.5 KiB
Python
326 lines
7.5 KiB
Python
"""
|
|
BAPSicle Server
|
|
Next-gen audio playout server for University Radio York playout,
|
|
based on WebStudio interface.
|
|
|
|
Flask Server
|
|
|
|
Authors:
|
|
Matthew Stratford
|
|
Michael Grace
|
|
|
|
Date:
|
|
October, November 2020
|
|
"""
|
|
|
|
import multiprocessing
|
|
import player
|
|
from flask import Flask, render_template, send_from_directory, request
|
|
import json
|
|
import setproctitle
|
|
import logging
|
|
from helpers.os_environment import isMacOS
|
|
from helpers.device_manager import DeviceManager
|
|
|
|
import pyttsx3
|
|
import config
|
|
from typing import Dict, List
|
|
|
|
setproctitle.setproctitle("BAPSicle - Server")
|
|
|
|
|
|
class BAPSicleServer():
|
|
def __init__(self):
|
|
startServer()
|
|
|
|
def __del__(self):
|
|
stopServer()
|
|
|
|
|
|
app = Flask(__name__, static_url_path='')
|
|
|
|
log = logging.getLogger('werkzeug')
|
|
log.disabled = True
|
|
app.logger.disabled = True
|
|
|
|
channel_to_q = []
|
|
channel_from_q = []
|
|
channel_p = []
|
|
|
|
stopping = False
|
|
|
|
|
|
### General Endpoints
|
|
|
|
@app.errorhandler(404)
|
|
def page_not_found(e):
|
|
data = {
|
|
'ui_page': "404",
|
|
"ui_title": "404"
|
|
}
|
|
return render_template('404.html', data=data), 404
|
|
|
|
|
|
@app.route("/")
|
|
def ui_index():
|
|
data = {
|
|
'ui_page': "index",
|
|
"ui_title": ""
|
|
}
|
|
return render_template('index.html', data=data)
|
|
|
|
|
|
@app.route("/config")
|
|
def ui_config():
|
|
channel_states = []
|
|
for i in range(3):
|
|
channel_states.append(status(i))
|
|
|
|
outputs = DeviceManager.getOutputs()
|
|
|
|
data = {
|
|
'channels': channel_states,
|
|
'outputs': outputs,
|
|
'ui_page': "config",
|
|
"ui_title": "Config"
|
|
}
|
|
return render_template('config.html', data=data)
|
|
|
|
|
|
@app.route("/status")
|
|
def ui_status():
|
|
channel_states = []
|
|
for i in range(3):
|
|
channel_states.append(status(i))
|
|
|
|
data = {
|
|
'channels': channel_states,
|
|
'ui_page': "status",
|
|
"ui_title": "Status"
|
|
}
|
|
return render_template('status.html', data=data)
|
|
|
|
### Channel Audio Options
|
|
|
|
@app.route("/player/<int:channel>/play")
|
|
def play(channel):
|
|
|
|
channel_to_q[channel].put("PLAY")
|
|
|
|
return ui_status()
|
|
|
|
|
|
@app.route("/player/<int:channel>/pause")
|
|
def pause(channel):
|
|
|
|
channel_to_q[channel].put("PAUSE")
|
|
|
|
return ui_status()
|
|
|
|
|
|
@app.route("/player/<int:channel>/unpause")
|
|
def unPause(channel):
|
|
|
|
channel_to_q[channel].put("UNPAUSE")
|
|
|
|
return ui_status()
|
|
|
|
|
|
@app.route("/player/<int:channel>/stop")
|
|
def stop(channel):
|
|
|
|
channel_to_q[channel].put("STOP")
|
|
|
|
return ui_status()
|
|
|
|
|
|
@app.route("/player/<int:channel>/seek/<int:pos>")
|
|
def seek(channel, pos):
|
|
|
|
channel_to_q[channel].put("SEEK:" + str(pos))
|
|
|
|
return ui_status()
|
|
|
|
|
|
@app.route("/player/<int:channel>/output/<name>")
|
|
def output(channel, name):
|
|
channel_to_q[channel].put("OUTPUT:" + name)
|
|
return ui_status()
|
|
|
|
@app.route("/player/<int:channel>/autoadvance/<int:state>")
|
|
def autoadvance(channel: int, state: int):
|
|
channel_to_q[channel].put("AUTOADVANCE:" + str(state))
|
|
return ui_status()
|
|
|
|
@app.route("/player/<int:channel>/repeat/<state>")
|
|
def repeat(channel: int, state):
|
|
channel_to_q[channel].put("REPEAT:" + state.upper())
|
|
return ui_status()
|
|
|
|
@app.route("/player/<int:channel>/playonload/<int:state>")
|
|
def playonload(channel: int, state: int):
|
|
channel_to_q[channel].put("PLAYONLOAD:" + str(state))
|
|
return ui_status()
|
|
|
|
### Channel Items
|
|
|
|
@app.route("/player/<int:channel>/load/<int:timeslotitemid>")
|
|
def load(channel:int, timeslotitemid: int):
|
|
channel_to_q[channel].put("LOAD:" + str(timeslotitemid))
|
|
return ui_status()
|
|
|
|
@app.route("/player/<int:channel>/unload")
|
|
def unload(channel):
|
|
|
|
channel_to_q[channel].put("UNLOAD")
|
|
|
|
return ui_status()
|
|
|
|
@app.route("/player/<int:channel>/add", methods=["POST"])
|
|
def add_to_plan(channel: int):
|
|
new_item: Dict[str, any] = {
|
|
"timeslotitemid": int(request.form["timeslotitemid"]),
|
|
"filename": request.form["filename"],
|
|
"title": request.form["title"],
|
|
"artist": request.form["artist"],
|
|
}
|
|
|
|
channel_to_q[channel].put("ADD:" + json.dumps(new_item))
|
|
|
|
return new_item
|
|
|
|
@app.route("/player/<int:channel>/move/<int:timeslotitemid>/<int:position>")
|
|
def move_plan(channel: int, timeslotitemid: int, position: int):
|
|
channel_to_q[channel].put("MOVE:" + json.dumps({"timeslotitemid": timeslotitemid, "position": position}))
|
|
|
|
#TODO Return
|
|
return True
|
|
|
|
@app.route("/player/<int:channel>/remove/<int:timeslotitemid>")
|
|
def remove_plan(channel: int, timeslotitemid: int):
|
|
channel_to_q[channel].put("REMOVE:" + timeslotitemid)
|
|
|
|
#TODO Return
|
|
return True
|
|
|
|
@app.route("/player/<int:channel>/clear")
|
|
def clear_channel_plan(channel: int):
|
|
channel_to_q[channel].put("CLEAR")
|
|
|
|
#TODO Return
|
|
return True
|
|
|
|
### General Channel Endpoints
|
|
|
|
@app.route("/player/<int:channel>/status")
|
|
def status(channel):
|
|
|
|
channel_to_q[channel].put("STATUS")
|
|
while True:
|
|
response = channel_from_q[channel].get()
|
|
if response.startswith("STATUS:"):
|
|
response = response[7:]
|
|
response = response[response.index(":")+1:]
|
|
try:
|
|
response = json.loads(response)
|
|
except:
|
|
pass
|
|
|
|
return response
|
|
|
|
|
|
@app.route("/quit")
|
|
def quit():
|
|
stopServer()
|
|
return "Shutting down..."
|
|
|
|
|
|
@app.route("/player/all/stop")
|
|
def all_stop():
|
|
for channel in channel_to_q:
|
|
channel.put("STOP")
|
|
return ui_status()
|
|
|
|
|
|
@app.route("/player/all/clear")
|
|
def clear_all_channels():
|
|
for channel in channel_to_q:
|
|
channel.put("CLEAR")
|
|
return ui_status()
|
|
|
|
|
|
@app.route('/static/<path:path>')
|
|
def send_static(path):
|
|
return send_from_directory('ui-static', path)
|
|
|
|
|
|
def startServer():
|
|
if isMacOS():
|
|
multiprocessing.set_start_method("spawn", True)
|
|
for channel in range(3):
|
|
|
|
channel_to_q.append(multiprocessing.Queue())
|
|
channel_from_q.append(multiprocessing.Queue())
|
|
channel_p.append(
|
|
multiprocessing.Process(
|
|
target=player.Player,
|
|
args=(channel, channel_to_q[-1], channel_from_q[-1]),
|
|
daemon=True
|
|
)
|
|
)
|
|
channel_p[channel].start()
|
|
|
|
# Welcome Speech
|
|
|
|
text_to_speach = pyttsx3.init()
|
|
text_to_speach.save_to_file(
|
|
"""Thank-you for installing BAPSicle - the play-out server from the broadcasting and presenting suite.
|
|
This server is accepting connections on port {0}
|
|
The version of the server service is {1}
|
|
Please refer to the documentation included with this application for further assistance.""".format(
|
|
config.PORT,
|
|
config.VERSION
|
|
),
|
|
"dev/welcome.mp3"
|
|
)
|
|
text_to_speach.runAndWait()
|
|
|
|
new_item: Dict[str, any] = {
|
|
"timeslotitemid": 0,
|
|
"filename": "dev/welcome.mp3",
|
|
"title": "Welcome to BAPSicle",
|
|
"artist": "University Radio York",
|
|
}
|
|
|
|
channel_to_q[0].put("ADD:" + json.dumps(new_item))
|
|
channel_to_q[0].put("LOAD:0")
|
|
channel_to_q[0].put("PLAY")
|
|
|
|
# Don't use reloader, it causes Nested Processes!
|
|
|
|
app.run(host='0.0.0.0', port=13500, debug=True, use_reloader=False)
|
|
|
|
def stopServer():
|
|
print("Stopping server.py")
|
|
for q in channel_to_q:
|
|
q.put("QUIT")
|
|
for player in channel_p:
|
|
try:
|
|
player.join()
|
|
except:
|
|
pass
|
|
print("Stopped all players.")
|
|
global stopping
|
|
if stopping == False:
|
|
stopping = True
|
|
shutdown = request.environ.get('werkzeug.server.shutdown')
|
|
if shutdown is None:
|
|
print("Shutting down Server.")
|
|
|
|
else:
|
|
print("Shutting down Flask.")
|
|
shutdown()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
print("BAPSicle is a service. Please run it like one.")
|