Congegni/sintonia
7
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Promoted pypo to top level because it isnt 3rd party.

Browse source 
Removed the portage stuff since it is way outdated.
This commit is contained in:
Paul Baranowski 2010-12-02 15:30:40 -05:00
parent 4300fd8d36
commit 51a1fde9ee
82 changed files with 0 additions and 6013 deletions
Download patch file Download diff file Expand all files Collapse all files

6
pypo/AUTHORS Normal file
View file

@ -0,0 +1,6 @@
This tool was born out of a collaboration between Open Broadcast
and Sourcefabric. The authors of the code are:
Jonas Ohrstrom <jonas@digris.ch>
Paul Baranowski <paul.baranowski@sourcefabric.org>

3
pypo/api_clients/__init__.py Normal file
View file

@ -0,0 +1,3 @@
# -*- coding: utf-8 -*-
__all__ = ["api_client"]

574
pypo/api_clients/api_client.py Normal file
View file

@ -0,0 +1,574 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
###############################################################################
# This file holds the implementations for all the API clients.
#
# If you want to develop a new client, here are some suggestions:
# Get the fetch methods working first, then the push, then the liquidsoap notifier.
# You will probably want to create a script on your server side to automatically
# schedule a playlist one minute from the current time.
###############################################################################
import sys
import time
import urllib
import logging
from util import json
import os
from urlparse import urlparse
def api_client_factory(config):
if config["api_client"] == "campcaster":
return CampcasterApiClient(config)
elif config["api_client"] == "obp":
return ObpApiClient(config)
else:
print 'API Client "'+config["api_client"]+'" not supported. Please check your config file.'
print
sys.exit()
class ApiClientInterface:
# Implementation: optional
#
# Called from: beginning of all scripts
#
# Should exit the program if this version of pypo is not compatible with
# 3rd party software.
def check_version(self):
pass
# Implementation: Required
#
# Called from: fetch loop
#
# This is the main method you need to implement when creating a new API client.
# start and end are for testing purposes.
# start and end are strings in the format YYYY-DD-MM-hh-mm-ss
def get_schedule(self, start=None, end=None):
return 0, []
# Implementation: Required
#
# Called from: fetch loop
#
# This downloads the media from the server.
def get_media(self, src, dst):
pass
# Implementation: optional
#
# Called from: push loop
#
# Tell server that the scheduled *playlist* has started.
def notify_scheduled_item_start_playing(self, pkey, schedule):
pass
# Implementation: optional
# You dont actually have to implement this function for the liquidsoap playout to work.
#
# Called from: pypo_notify.py
#
# This is a callback from liquidsoap, we use this to notify about the
# currently playing *song*. We get passed a JSON string which we handed to
# liquidsoap in get_liquidsoap_data().
def notify_media_item_start_playing(self, data, media_id):
pass
# Implementation: optional
# You dont actually have to implement this function for the liquidsoap playout to work.
def generate_range_dp(self):
pass
# Implementation: optional
#
# Called from: push loop
#
# Return a dict of extra info you want to pass to liquidsoap
# You will be able to use this data in update_start_playing
def get_liquidsoap_data(self, pkey, schedule):
pass
# Put here whatever tests you want to run to make sure your API is working
def test(self):
pass
#def get_media_type(self, playlist):
# nil
################################################################################
# Campcaster API Client
################################################################################
class CampcasterApiClient(ApiClientInterface):
def __init__(self, config):
self.config = config
def __get_campcaster_version(self):
logger = logging.getLogger()
url = self.config["base_url"] + self.config["api_base"] + self.config["version_url"]
url = url.replace("%%api_key%%", self.config["api_key"])
try:
logger.debug("Trying to contact %s", url)
response = urllib.urlopen(url)
data = response.read()
logger.debug("Data: %s", data)
response_json = json.read(data)
version = response_json['version']
logger.debug("Campcaster Version %s detected", version)
except Exception, e:
try:
if e[1] == 401:
print '#####################################'
print '# YOUR API KEY SEEMS TO BE INVALID:'
print '# ' + self.config["api_key"]
print '#####################################'
sys.exit()
except Exception, e:
pass
try:
if e[1] == 404:
print '#####################################'
print '# Unable to contact the Campcaster-API'
print '# ' + url
print '#####################################'
sys.exit()
except Exception, e:
pass
version = 0
logger.error("Unable to detect Campcaster Version - %s", e)
return version
def test(self):
logger = logging.getLogger()
status, items = self.get_schedule('2010-01-01-00-00-00', '2011-01-01-00-00-00')
schedule = items["playlists"]
logger.debug("Number of playlists found: %s", str(len(schedule)))
count = 1
for pkey in sorted(schedule.iterkeys()):
logger.debug("Playlist #%s",str(count))
count+=1
#logger.info("found playlist at %s", pkey)
playlist = schedule[pkey]
for item in playlist["medias"]:
filename = urlparse(item["uri"])
filename = filename.query[5:]
self.get_media(item["uri"], filename)
def check_version(self):
version = self.__get_campcaster_version()
if (version == 0):
print 'Unable to get Campcaster version number.'
print
sys.exit()
elif (version[0:4] != "1.6."):
print 'Campcaster version: ' + str(version)
print 'pypo not compatible with this version of Campcaster.'
print
sys.exit()
else:
print 'Campcaster version: ' + str(version)
print 'pypo is compatible with this version of Campcaster.'
print
def get_schedule(self, start=None, end=None):
logger = logging.getLogger()
"""
calculate start/end time range (format: YYYY-DD-MM-hh-mm-ss,YYYY-DD-MM-hh-mm-ss)
(seconds are ignored, just here for consistency)
"""
tnow = time.localtime(time.time())
if (not start):
tstart = time.localtime(time.time() - 3600 * int(self.config["cache_for"]))
start = "%04d-%02d-%02d-%02d-%02d" % (tstart[0], tstart[1], tstart[2], tstart[3], tstart[4])
if (not end):
tend = time.localtime(time.time() + 3600 * int(self.config["prepare_ahead"]))
end = "%04d-%02d-%02d-%02d-%02d" % (tend[0], tend[1], tend[2], tend[3], tend[4])
range = {}
range['start'] = start
range['end'] = end
# Construct the URL
export_url = self.config["base_url"] + self.config["api_base"] + self.config["export_url"]
#logger.debug("Exporting schedule using URL: "+export_url)
# Insert the start and end times into the URL
export_url = export_url.replace('%%api_key%%', self.config["api_key"])
export_url = export_url.replace('%%from%%', range['start'])
export_url = export_url.replace('%%to%%', range['end'])
logger.info("Fetching schedule from %s", export_url)
response = ""
status = 0
try:
response_json = urllib.urlopen(export_url).read()
#logger.debug("%s", response_json)
response = json.read(response_json)
#logger.info("export status %s", response['check'])
status = response['check']
except Exception, e:
print e
#schedule = response["playlists"]
#scheduleKeys = sorted(schedule.iterkeys())
#
## Remove all playlists that have passed current time
#try:
# tnow = time.localtime(time.time())
# str_tnow_s = "%04d-%02d-%02d-%02d-%02d-%02d" % (tnow[0], tnow[1], tnow[2], tnow[3], tnow[4], tnow[5])
# toRemove = []
# for pkey in scheduleKeys:
# if (str_tnow_s > schedule[pkey]['end']):
# toRemove.append(pkey)
# else:
# break
# #logger.debug("Remove keys: %s", toRemove)
# for index in toRemove:
# del schedule[index]
# #logger.debug("Schedule dict: %s", schedule)
#except Exception, e:
# logger.debug("'Ignore Past Playlists' feature not supported by API: %s", e)
#response["playlists"] = schedule
return status, response
def get_media(self, src, dst):
logger = logging.getLogger()
try:
src = src + "&api_key=" + self.config["api_key"]
# check if file exists already before downloading again
filename, headers = urllib.urlretrieve(src, dst)
logger.info("downloaded %s to %s", src, dst)
except Exception, e:
logger.error("%s", e)
"""
Tell server that the scheduled *playlist* has started.
"""
def notify_scheduled_item_start_playing(self, pkey, schedule):
logger = logging.getLogger()
playlist = schedule[pkey]
schedule_id = playlist["schedule_id"]
url = self.config["base_url"] + self.config["api_base"] + self.config["update_item_url"]
url = url.replace("%%schedule_id%%", str(schedule_id))
url += "&api_key=" + self.config["api_key"]
logger.debug(url)
try:
response = urllib.urlopen(url)
response = json.read(response.read())
logger.info("API-Status %s", response['status'])
logger.info("API-Message %s", response['message'])
except Exception, e:
logger.critical("Unable to connect - %s", e)
return response
"""
This is a callback from liquidsoap, we use this to notify about the
currently playing *song*. We get passed a JSON string which we handed to
liquidsoap in get_liquidsoap_data().
"""
def notify_media_item_start_playing(self, data, media_id):
logger = logging.getLogger()
response = ''
if (data[0] != '{'):
return response
try:
data = json.read(data)
logger.debug(str(data))
schedule_id = data["schedule_id"]
url = self.config["base_url"] + self.config["api_base"] + self.config["update_start_playing_url"]
url = url.replace("%%media_id%%", str(media_id))
url = url.replace("%%schedule_id%%", str(schedule_id))
url += "&api_key=" + self.config["api_key"]
logger.debug(url)
response = urllib.urlopen(url)
response = json.read(response.read())
logger.info("API-Status %s", response['status'])
logger.info("API-Message %s", response['message'])
except Exception, e:
logger.critical("Exception: %s", e)
return response
def generate_range_dp(self):
pass
#logger = logging.getLogger()
#
#url = self.api_url + 'schedule/generate_range_dp.php'
#
#try:
# response = urllib.urlopen(url, self.api_auth)
# response = json.read(response.read())
# logger.debug("Trying to contact %s", url)
# logger.info("API-Status %s", response['status'])
# logger.info("API-Message %s", response['message'])
#
#except Exception, e:
# print e
# api_status = False
# logger.critical("Unable to handle the request - %s", e)
#
#return response
def get_liquidsoap_data(self, pkey, schedule):
logger = logging.getLogger()
playlist = schedule[pkey]
data = dict()
try:
data["schedule_id"] = playlist['id']
except Exception, e:
data["schedule_id"] = 0
data = json.write(data)
return data
################################################################################
# OpenBroadcast API Client
################################################################################
# Also check out the php counterpart that handles the api requests:
# https://lab.digris.ch/svn/elgg/trunk/unstable/mod/medialibrary/application/controllers/api/pypo.php
OBP_MIN_VERSION = 2010100101 # required obp version
class ObpApiClient():
def __init__(self, config):
self.config = config
self.api_auth = urllib.urlencode({'api_key': self.config["api_key"]})
def check_version(self):
obp_version = self.get_obp_version()
if obp_version == 0:
print '#################################################'
print 'Unable to get OBP version. Is OBP up and running?'
print '#################################################'
print
sys.exit()
elif obp_version < OBP_MIN_VERSION:
print 'OBP version: ' + str(obp_version)
print 'OBP min-version: ' + str(OBP_MIN_VERSION)
print 'pypo not compatible with this version of OBP'
print
sys.exit()
else:
print 'OBP API: ' + str(API_BASE)
print 'OBP version: ' + str(obp_version)
print 'OBP min-version: ' + str(OBP_MIN_VERSION)
print 'pypo is compatible with this version of OBP'
print
def get_obp_version(self):
logger = logging.getLogger()
# lookup OBP version
url = self.config["base_url"] + self.config["api_base"]+ self.config["version_url"]
try:
logger.debug("Trying to contact %s", url)
response = urllib.urlopen(url, self.api_auth)
response_json = json.read(response.read())
obp_version = int(response_json['version'])
logger.debug("OBP Version %s detected", obp_version)
except Exception, e:
try:
if e[1] == 401:
print '#####################################'
print '# YOUR API KEY SEEMS TO BE INVALID'
print '# ' + self.config["api_auth"]
print '#####################################'
sys.exit()
except Exception, e:
pass
try:
if e[1] == 404:
print '#####################################'
print '# Unable to contact the OBP-API'
print '# ' + url
print '#####################################'
sys.exit()
except Exception, e:
pass
obp_version = 0
logger.error("Unable to detect OBP Version - %s", e)
return obp_version
def get_schedule(self, start=None, end=None):
logger = logging.getLogger()
"""
calculate start/end time range (format: YYYY-DD-MM-hh-mm-ss,YYYY-DD-MM-hh-mm-ss)
(seconds are ignored, just here for consistency)
"""
tnow = time.localtime(time.time())
if (not start):
tstart = time.localtime(time.time() - 3600 * int(self.config["cache_for"]))
start = "%04d-%02d-%02d-%02d-%02d" % (tstart[0], tstart[1], tstart[2], tstart[3], tstart[4])
if (not end):
tend = time.localtime(time.time() + 3600 * int(self.config["prepare_ahead"]))
end = "%04d-%02d-%02d-%02d-%02d" % (tend[0], tend[1], tend[2], tend[3], tend[4])
range = {}
range['start'] = start
range['end'] = end
# Construct the URL
export_url = self.config["base_url"] + self.config["api_base"] + self.config["export_url"]
# Insert the start and end times into the URL
export_url = export_url.replace('%%api_key%%', self.config["api_key"])
export_url = export_url.replace('%%from%%', range['start'])
export_url = export_url.replace('%%to%%', range['end'])
logger.info("export from %s", export_url)
response = ""
status = 0
try:
response_json = urllib.urlopen(export_url).read()
logger.debug("%s", response_json)
response = json.read(response_json)
logger.info("export status %s", response['check'])
status = response['check']
except Exception, e:
print e
return status, response
def get_media(self, src, dest):
try:
print '** urllib auth with: ',
print self.api_auth
urllib.urlretrieve(src, dst, False, self.api_auth)
logger.info("downloaded %s to %s", src, dst)
except Exception, e:
logger.error("%s", e)
"""
Tell server that the scheduled *playlist* has started.
"""
def notify_scheduled_item_start_playing(self, pkey, schedule):
#def update_scheduled_item(self, item_id, value):
logger = logging.getLogger()
url = self.config["base_url"] + self.config["api_base"] + self.config["update_item_url"]
url = url.replace("%%item_id%%", str(schedule[pkey]["id"]))
url = url.replace("%%played%%", "1")
try:
response = urllib.urlopen(url, self.api_auth)
response = json.read(response.read())
logger.info("API-Status %s", response['status'])
logger.info("API-Message %s", response['message'])
except Exception, e:
print e
api_status = False
logger.critical("Unable to connect to the OBP API - %s", e)
return response
"""
This is a callback from liquidsoap, we use this to notify about the
currently playing *song*. We get passed a JSON string which we handed to
liquidsoap in get_liquidsoap_data().
"""
def notify_media_item_start_playing(self, data, media_id):
# def update_start_playing(self, playlist_type, export_source, media_id, playlist_id, transmission_id):
logger = logging.getLogger()
playlist_type = data["playlist_type"]
export_source = data["export_source"]
playlist_id = data["playlist_id"]
transmission_id = data["transmission_id"]
url = self.config["base_url"] + self.config["api_base"] + self.config["update_start_playing_url"]
url = url.replace("%%playlist_type%%", str(playlist_type))
url = url.replace("%%export_source%%", str(export_source))
url = url.replace("%%media_id%%", str(media_id))
url = url.replace("%%playlist_id%%", str(playlist_id))
url = url.replace("%%transmission_id%%", str(transmission_id))
print url
try:
response = urllib.urlopen(url, self.api_auth)
response = json.read(response.read())
logger.info("API-Status %s", response['status'])
logger.info("API-Message %s", response['message'])
logger.info("TXT %s", response['str_dls'])
except Exception, e:
print e
api_status = False
logger.critical("Unable to connect to the OBP API - %s", e)
return response
def generate_range_dp(self):
logger = logging.getLogger()
url = self.config["base_url"] + self.config["api_base"] + self.config["generate_range_url"]
try:
response = urllib.urlopen(url, self.api_auth)
response = json.read(response.read())
logger.debug("Trying to contact %s", url)
logger.info("API-Status %s", response['status'])
logger.info("API-Message %s", response['message'])
except Exception, e:
print e
api_status = False
logger.critical("Unable to handle the OBP API request - %s", e)
return response
def get_liquidsoap_data(self, pkey, schedule):
playlist = schedule[pkey]
data = dict()
data["ptype"] = playlist['subtype']
try:
data["user_id"] = playlist['user_id']
data["playlist_id"] = playlist['id']
data["transmission_id"] = playlist['schedule_id']
except Exception, e:
data["playlist_id"] = 0
data["user_id"] = 0
data["transmission_id"] = 0
data = json.write(data)
return data

9
pypo/api_clients/api_client_factory.py Normal file
View file

@ -0,0 +1,9 @@
import campcaster_api_client
import obp_api_client
def create_api_client(config):
if config["api_client"] == "campcaster":
return campcaster_api_client.CampcasterApiClient(config)
elif config["api_client"] == "obp":
return obp_api_client.ObpApiClient(config)

121
pypo/config.cfg Normal file
View file

@ -0,0 +1,121 @@
############################################
# pypo - configuration #
############################################
# Set the type of client you are using.
# Currently supported types:
# 1) "obp" = Open Broadcast Platform
# 2) "campcaster"
#
api_client = "campcaster"
############################################
# Directories / Hosts #
# _include_ trailing slash !! #
############################################
cache_dir = '/opt/pypo/cache/'
file_dir = '/opt/pypo/files/'
tmp_dir = '/opt/pypo/tmp/'
# Hostname
base_url = 'http://localhost/'
############################################
# Liquidsoap settings #
############################################
ls_host = '127.0.0.1'
ls_port = '1234'
############################################
# pypo preferences #
############################################
prepare_ahead = 24 #in hours
cache_for = 24 #how long to hold the cache, in hours
# Poll interval in seconds.
#
# This is how often the poll script downloads new schedules and files from the
# server.
#
# For production use, this number depends on whether you plan on making any
# last-minute changes to your schedule. This number should be set to half of
# the time you expect to "lock-in" your schedule. So if your schedule is set
# 24 hours in advance, this can be set to poll every 12 hours.
#
poll_interval = 10 # in seconds.
# Push interval in seconds.
#
# This is how often the push script checks whether it has something new to
# push to liquidsoap.
#
# It's hard to imagine a situation where this should be more than 1 second.
#
push_interval = 1 # in seconds
# 'pre' or 'otf'. 'pre' cues while playlist preparation
# while 'otf' (on the fly) cues while loading into ls
# (needs the post_processor patch)
cue_style = 'pre'
################################################################################
# Uncomment *one of the sets* of values from the API clients below, and comment
# out all the others.
################################################################################
#####################
# Campcaster Config #
#####################
# Value needed to access the API
api_key = 'AAA'
# Path to the base of the API
api_base = 'campcaster/'
# URL to get the version number of the server API
version_url = 'api/api_version.php?api_key=%%api_key%%'
# Schedule export path.
# %%from%% - starting date/time in the form YYYY-MM-DD-hh-mm
# %%to%% - starting date/time in the form YYYY-MM-DD-hh-mm
export_url = 'api/schedule.php?from=%%from%%&to=%%to%%&api_key=%%api_key%%'
# Update whether a schedule group has begun playing.
update_item_url = 'api/notify_schedule_group_play.php?schedule_id=%%schedule_id%%'
# Update whether an audio clip is currently playing.
update_start_playing_url = 'api/notify_media_item_start_play.php?media_id=%%media_id%%&schedule_id=%%schedule_id%%'
# ???
generate_range_url = 'api/generate_range_dp.php'
##############
# OBP config #
##############
# Value needed to access the API
#api_key = 'AAA'
#base_url = 'http://localhost/'
# Path to the base of the API
#api_base = ''
# URL to get the version number of the server API
#version_url = 'api/pypo/status/json'
# Schedule export path.
# %%from%% - starting date/time in the form YYYY-MM-DD-hh-mm
# %%to%% - starting date/time in the form YYYY-MM-DD-hh-mm
# Update whether an item has been played.
#update_item_url = 'api/pypo/update_shedueled_item/$$item_id%%?played=%%played%%'
# Update whether an item is currently playing.
#update_start_playing_url = 'api/pypo/mod/medialibrary/?playlist_type=%%playlist_type%%&export_source=%%export_source%%&media_id=%%media_id%%&playlist_id=%%playlist_id%%&transmission_id=%%transmission_id%%'
# ???
#generate_range_url = 'api/pypo/generate_range_dp/'

40
pypo/config.cfg.dist Executable file
View file

@ -0,0 +1,40 @@
############################################
# pypo - configuration #
############################################
############################################
# Directories / Hosts #
# _include_ trailing slash !! #
############################################
cache_dir = '/storage/pypo/cache/'
file_dir = '/storage/pypo/files/'
tmp_dir = '/var/tmp/obp/'
############################################
# API path & co #
############################################
base_url = 'http://test.local.obp.ch/'
obp_api_key = 'AAA-BBB-CCC-EEE'
export_path = 'api/pypo/export_range/' # YYYY-MM-DD-hh-mm will be added in script, exports json
export_source = 'scheduler' # choose "dayparts" or "scheduler"
############################################
# Liquidsoap settings #
############################################
ls_host = '127.0.0.1'
ls_port = '1234'
############################################
# pypo preferences #
############################################
prepare_ahead = 12 #in hours
cache_for = 12 #how long to hold the cache, in hours
poll_interval = 10 # in seconds
push_interval = 1 # in seconds
# 'pre' or 'otf'. 'pre' cues while pplaylist preparation
# while 'otf' (on the fly) cues while loading into ls
# (needs the post_processor patch)
cue_style = 'pre'

3
pypo/dls/__init__.py Normal file
View file

@ -0,0 +1,3 @@
# -*- coding: utf-8 -*-
from dls_client import *

90
pypo/dls/dls_client.py Executable file
View file

@ -0,0 +1,90 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author Jonas Ohrstrom <jonas@digris.ch>
import sys
import time
import logging
from util import json
import os
import socket
class DlsClient():
def __init__(self, dls_host, dls_port, dls_user, dls_pass):
self.dls_host = dls_host
self.dls_port = dls_port
self.dls_user = dls_user
self.dls_pass = dls_pass
def set_txt(self, txt):
logger = logging.getLogger("DlsClient.set_txt")
try:
print 'trying to update dls'
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self.dls_host, self.dls_port))
s.send('client_zzzz')
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('RS_DLS_VERSION' + ' ' + '1')
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('SERVICE' + ' ' + self.dls_user)
s.send("\r\n")
s.send('PASSWORD' + ' ' + self.dls_pass)
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('SET_DLS_CHARSET' + ' ' + '4')
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('CLEAR_DLS')
s.send("\r\n")
s.send('SET_DLS' + ' ' + txt)
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('CLOSE_DLS')
s.send("\r\n")
data = s.recv(1024)
print data;
s.close()
print 'OK'
except Exception, e:
#print e
print 'did not work out.'
dls_status = False
logger.info("Unable to connect to the update metadata - %s", e)
return

61
pypo/logging.cfg Normal file
View file

@ -0,0 +1,61 @@
[loggers]
keys=root
[handlers]
keys=consoleHandler,fileHandlerERROR,fileHandlerDEBUG,nullHandler
[formatters]
keys=simpleFormatter
[logger_root]
level=DEBUG
handlers=consoleHandler,fileHandlerERROR,fileHandlerDEBUG
[logger_libs]
handlers=nullHandler
level=DEBUG
qualname="process"
propagate=0
[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=simpleFormatter
args=(sys.stdout,)
[handler_fileHandlerERROR]
class=FileHandler
level=WARNING
formatter=simpleFormatter
args=("./error.log",)
[handler_fileHandlerDEBUG]
class=FileHandler
level=DEBUG
formatter=simpleFormatter
args=("./debug.log",)
[handler_nullHandler]
class=FileHandler
level=DEBUG
formatter=simpleFormatter
args=("/tmp/sessionlog_null.log",)
[formatter_simpleFormatter]
format=%(asctime)s %(levelname)s - [%(filename)s : %(funcName)s() : line %(lineno)d] - %(message)s
datefmt=
## multitail color sheme
## pyml / python
# colorscheme:pyml:www.obp.net
# cs_re:blue:\[[^ ]*\]
# cs_re:red:CRITICAL:*
# cs_re:red,black,blink:ERROR:*
# cs_re:blue:NOTICE:*
# cs_re:cyan:INFO:*
# cs_re:green:DEBUG:*

251
pypo/push.py Executable file
View file

@ -0,0 +1,251 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Python part of radio playout (pypo)
The main functionas are "fetch" (./pypo_cli.py -f) and "push" (./pypo_cli.py -p)
Also check out the php counterpart that handles the api requests:
https://lab.digris.ch/svn/elgg/trunk/unstable/mod/medialibrary/application/controllers/api/pypo.php
Attention & ToDos
- liquidsoap does not like mono files! So we have to make sure that only files with
2 channels are fed to LS
(solved: current = audio_to_stereo(current) - maybe not with ultimate performance)
made for python version 2.5!!
should work with 2.6 as well with a bit of adaption. for
sure the json parsing has to be changed
(2.6 has an parser, pypo brigs it's own -> util/json.py)
"""
# python defaults (debian default)
import time
import os
import traceback
from optparse import *
import sys
import time
import datetime
import logging
import logging.config
import shutil
import urllib
import urllib2
import pickle
import telnetlib
import random
import string
import operator
# additional modules (should be checked)
from configobj import ConfigObj
# custom imports
from util import *
from obp import *
PYPO_VERSION = '0.1'
#set up command-line options
parser = OptionParser()
# help screeen / info
usage = "%prog [options]" + " - python playout system"
parser = OptionParser(usage=usage)
#options
parser.add_option("-f", "--fetch", help="Fetch Schedule (loop, interval in config file)", default=False, action="store_true", dest="fetch")
parser.add_option("-p", "--push", help="Push pl to Liquidsoap (loop, interval in config file)", default=False, action="store_true", dest="push")
parser.add_option("-b", "--cleanup", help="Faeili Butzae aka cleanup", default=False, action="store_true", dest="cleanup")
parser.add_option("-j", "--jingles", help="Get new jungles from obp, comma separated list if jingle-id's as argument", metavar="LIST")
parser.add_option("-c", "--check", help="Check the cached schedule and exit", default=False, action="store_true", dest="check")
parser.add_option("-P", "--pushpkey", help="Push PKEY", metavar="LIST")
# parse options
(options, args) = parser.parse_args()
# configure logging
logging.config.fileConfig("logging.cfg")
# loading config file
try:
config = ConfigObj('config.cfg')
CACHE_DIR = config['cache_dir']
FILE_DIR = config['file_dir']
TMP_DIR = config['tmp_dir']
BASE_URL = config['base_url']
API_BASE = config['api_base']
EXPORT_SOURCE = config['export_source']
OBP_API_KEY = config['api_key']
POLL_INTERVAL = float(config['poll_interval'])
PUSH_INTERVAL = float(config['push_interval'])
LS_HOST = config['ls_host']
LS_PORT = config['ls_port']
PREPARE_AHEAD = config['prepare_ahead']
CACHE_FOR = config['cache_for']
CUE_STYLE = config['cue_style']
except Exception, e:
print 'error: ', e
sys.exit()
#TIME = time.localtime(time.time())
TIME = (2010, 6, 26, 15, 33, 23, 2, 322, 0)
class Global:
def __init__(self):
#print '# global initialisation'
print
def selfcheck(self):
self.api_auth = urllib.urlencode({'api_key': API_KEY})
self.api_client = ApiClient(API_BASE, self.api_auth)
self.api_client.check_version()
"""
Uncomment the following lines to let pypo check if
liquidsoap is running. (checks for a telnet server)
"""
# while self.status.check_ls(LS_HOST, LS_PORT) == 0:
# print 'Unable to connect to liquidsoap. Is it up and running?'
# time.sleep(2)
"""
"""
class Playout:
def __init__(self):
#print '# init fallback'
self.cache_dir = CACHE_DIR
self.file_dir = FILE_DIR
self.tmp_dir = TMP_DIR
self.export_source = EXPORT_SOURCE
self.api_auth = urllib.urlencode({'api_key': API_KEY})
self.api_client = ApiClient(API_BASE, self.api_auth)
self.cue_file = CueFile()
self.schedule_file = CACHE_DIR + 'schedule'
# set initial state
self.range_updated = False
def push_liquidsoap(self,options):
logger = logging.getLogger("push_liquidsoap")
print options
#pkey = '2010-10-26-21-00-00'
pkey = options
src = self.cache_dir + str(pkey) + '/list.lsp'
print src
s
if True == os.access(src, os.R_OK):
print 'OK - Can read'
pl_file = open(src, "r")
"""
i know this could be wrapped, maybe later..
"""
tn = telnetlib.Telnet(LS_HOST, 1234)
#tn.write("\n")
for line in pl_file.readlines():
print line.strip()
#tn.write('q.push ' + pl_entry)
#tn.write("\n")
tn.write('scheduler.push %s' % (line.strip()))
tn.write("\n")
tn.write("scheduler_q0.queue \n")
tn.write("scheduler_q1.queue \n")
#time.sleep(2)
#print tn.read_all()
print 'sending "flip"'
tn.write('scheduler.flip')
tn.write("\n")
#tn.write("live_in.stop\n")
#tn.write("stream_disable\n")
#time.sleep(0.2)
#tn.write("\n")
#tn.write("reload_current\n")
#tn.write("current.reload\n")
#time.sleep(0.2)
#tn.write("skip_current\n")
# if(int(ptype) == 6):
# """
# Couchcaster / Recast comming. Stop/Start live input to have ls re-read it's playlist
# """
# print 'Couchcaster - switching to stream'
# tn.write("live_in.start\n")
# time.sleep(0.2)
# tn.write("stream_enable\n")
#
#
#
# """
# Pass some extra information to liquidsoap
# """
# tn.write("pl.pl_id '%s'\n" % p_id)
# tn.write("pl.user_id '%s'\n" % user_id)
tn.write("exit\n")
print tn.read_all()
status = 1
sys.exit()
# except Exception, e:
# logger.error('%s', e)
# status = 0
if __name__ == '__main__':
print
print '#########################################'
print '# *** pypo *** #'
print '# obp python playout #'
print '#########################################'
print
# initialize
g = Global()
g.selfcheck()
po = Playout()
run = True
while run == True:
logger = logging.getLogger("pypo")
while options.pushpkey:
try: po.push_liquidsoap(options.pushpkey)
except Exception, e:
print e
sys.exit()
while options.push:
po.push_liquidsoap()
sys.exit()

962
pypo/pypo_cli.py Executable file
View file

@ -0,0 +1,962 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Python part of radio playout (pypo)
The main functions are "fetch" (./pypo_cli.py -f) and "push" (./pypo_cli.py -p)
There are two layers: scheduler & daypart (fallback)
The daypart is a fallback-layer generated by the playlists daypart-settings
(eg a playlist creator can say that the list is good for Monday and Tues,
between 14:00 and 16:00). So if there is nothing in the schedule, pypo will
still play something (instead of silence..) This layer is optional.
It is there so that you dont have a fallback player which plays the same 100
tracks over and over again.
Attention & ToDos
- liquidsoap does not like mono files! So we have to make sure that only files with
2 channels are fed to LiquidSoap
(solved: current = audio_to_stereo(current) - maybe not with ultimate performance)
made for python version 2.5!!
should work with 2.6 as well with a bit of adaption. for
sure the json parsing has to be changed
(2.6 has an parser, pypo brings it's own -> util/json.py)
"""
# python defaults (debian default)
import time
import os
import traceback
from optparse import *
import sys
import time
import datetime
import logging
import logging.config
import shutil
import urllib
import urllib2
import pickle
import telnetlib
import random
import string
import operator
import inspect
# additional modules (should be checked)
from configobj import ConfigObj
# custom imports
from util import *
from api_clients import *
PYPO_VERSION = '0.2'
PYPO_MEDIA_SKIP = 1
PYPO_MEDIA_LIVE_SESSION = 2
PYPO_MEDIA_STREAM = 3
PYPO_MEDIA_FILE_URL = 4
PYPO_MEDIA_FILE_LOCAL = 5
# Set up command-line options
parser = OptionParser()
# help screeen / info
usage = "%prog [options]" + " - python playout system"
parser = OptionParser(usage=usage)
# Options
parser.add_option("-v", "--compat", help="Check compatibility with server API version", default=False, action="store_true", dest="check_compat")
parser.add_option("-t", "--test", help="Do a test to make sure everything is working properly.", default=False, action="store_true", dest="test")
parser.add_option("-f", "--fetch-scheduler", help="Fetch the schedule from server. This is a polling process that runs forever.", default=False, action="store_true", dest="fetch_scheduler")
parser.add_option("-p", "--push-scheduler", help="Push the schedule to Liquidsoap. This is a polling process that runs forever.", default=False, action="store_true", dest="push_scheduler")
parser.add_option("-F", "--fetch-daypart", help="Fetch from daypart - scheduler (loop, interval in config file)", default=False, action="store_true", dest="fetch_daypart")
parser.add_option("-P", "--push-daypart", help="Push daypart to Liquidsoap (loop, interval in config file)", default=False, action="store_true", dest="push_daypart")
parser.add_option("-b", "--cleanup", help="Cleanup", default=False, action="store_true", dest="cleanup")
#parser.add_option("-j", "--jingles", help="Get new jingles from server, comma separated list if jingle-id's as argument", metavar="LIST")
parser.add_option("-c", "--check", help="Check the cached schedule and exit", default=False, action="store_true", dest="check")
# parse options
(options, args) = parser.parse_args()
# configure logging
logging.config.fileConfig("logging.cfg")
# loading config file
try:
config = ConfigObj('config.cfg')
POLL_INTERVAL = float(config['poll_interval'])
PUSH_INTERVAL = float(config['push_interval'])
LS_HOST = config['ls_host']
LS_PORT = config['ls_port']
except Exception, e:
print 'Error loading config file: ', e
sys.exit()
class Global:
def __init__(self):
print
def selfcheck(self):
self.api_client = api_client.api_client_factory(config)
self.api_client.check_version()
"""
"""
class Playout:
def __init__(self):
self.api_client = api_client.api_client_factory(config)
self.cue_file = CueFile()
self.silence_file = config["file_dir"] + 'basic/silence.mp3'
self.push_ahead = 15
self.range_updated = False
def test_api(self):
self.api_client.test()
def set_export_source(self, export_source):
self.export_source = export_source
self.cache_dir = config["cache_dir"] + self.export_source + '/'
self.schedule_file = self.cache_dir + 'schedule.pickle'
self.schedule_tracker_file = self.cache_dir + "schedule_tracker.pickle"
"""
Fetching part of pypo
- Reads the scheduled entries of a given range (actual time +/- "prepare_ahead" / "cache_for")
- Saves a serialized file of the schedule
- playlists are prepared. (brought to liquidsoap format) and, if not mounted via nsf, files are copied
to the cache dir (Folder-structure: cache/YYYY-MM-DD-hh-mm-ss)
- runs the cleanup routine, to get rid of unused cashed files
"""
def fetch(self, export_source):
"""
wrapper script for fetching the whole schedule (in json)
"""
logger = logging.getLogger()
self.set_export_source(export_source)
try: os.mkdir(self.cache_dir)
except Exception, e: pass
"""
Trigger daypart range-generation. (Only if daypart-instance)
"""
if self.export_source == 'daypart':
print '******************************'
print '*** TRIGGER DAYPART UPDATE ***'
print '******************************'
try:
self.generate_range_dp()
except Exception, e:
logger.error("%s", e)
# get schedule
try:
while self.get_schedule() != 1:
logger.warning("failed to read from export url")
time.sleep(1)
except Exception, e: logger.error("%s", e)
# prepare the playlists
if config["cue_style"] == 'pre':
try: self.prepare_playlists_cue()
except Exception, e: logger.error("%s", e)
elif config["cue_style"] == 'otf':
try: self.prepare_playlists(self.export_source)
except Exception, e: logger.error("%s", e)
# cleanup
try: self.cleanup(self.export_source)
except Exception, e: logger.error("%s", e)
logger.info("fetch loop completed")
"""
This is actually a bit ugly (again feel free to improve!!)
The generate_range_dp function should be called once a day,
we do this at 18h. The hour before the state is set back to 'False'
"""
def generate_range_dp(self):
logger = logging.getLogger()
logger.debug("trying to trigger daypart update")
tnow = time.localtime(time.time())
if (tnow[3] == 16):
self.range_updated = False
if (tnow[3] == 17 and self.range_updated == False):
try:
print self.api_client.generate_range_dp()
logger.info("daypart updated")
self.range_updated = True
except Exception, e:
print e
def get_schedule(self):
logger = logging.getLogger()
status, response = self.api_client.get_schedule();
if status == 1:
logger.info("dump serialized schedule to %s", self.schedule_file)
schedule = response['playlists']
try:
schedule_file = open(self.schedule_file, "w")
pickle.dump(schedule, schedule_file)
schedule_file.close()
except Exception, e:
logger.critical("Exception %s", e)
status = 0
return status
"""
Alternative version of playout preparation. Every playlist entry is
pre-cued if neccessary (cue_in/cue_out != 0) and stored in the
playlist folder.
file is eg 2010-06-23-15-00-00/17_cue_10.132-123.321.mp3
"""
def prepare_playlists_cue(self):
logger = logging.getLogger()
# Load schedule from disk
schedule = self.load_schedule()
# Dont do anything if schedule is empty
if (not schedule):
logger.debug("Schedule is empty.")
return
scheduleKeys = sorted(schedule.iterkeys())
try:
for pkey in scheduleKeys:
logger.info("found playlist at %s", pkey)
playlist = schedule[pkey]
# create playlist directory
try:
os.mkdir(self.cache_dir + str(pkey))
except Exception, e:
pass
ls_playlist = '';
logger.debug('*****************************************')
logger.debug('pkey: ' + str(pkey))
logger.debug('cached at : ' + self.cache_dir + str(pkey))
logger.debug('subtype: ' + str(playlist['subtype']))
logger.debug('played: ' + str(playlist['played']))
logger.debug('schedule id: ' + str(playlist['schedule_id']))
logger.debug('duration: ' + str(playlist['duration']))
logger.debug('source id: ' + str(playlist['x_ident']))
logger.debug('*****************************************')
# Creating an API call like the next two lines would make this more flexible
# mediaType = api_client.get_media_type(playlist)
# if (mediaType == PYPO_MEDIA_SKIP):
if int(playlist['played']) == 1:
logger.info("playlist %s already played / sent to liquidsoap, so will ignore it", pkey)
elif int(playlist['subtype']) == 5:
ls_playlist = self.handle_live_session(playlist, pkey, ls_playlist)
elif int(playlist['subtype']) == 6:
ls_playlist = self.handle_live_cast(playlist, pkey, ls_playlist)
elif int(playlist['subtype']) > 0 and int(playlist['subtype']) < 5:
ls_playlist = self.handle_media_file(playlist, pkey, ls_playlist)
"""
This is kind of hackish. We add a bunch of "silence" tracks to the end of each playlist.
So we can make sure the list does not get repeated just before a new one is called.
(or in case nothing is in the scheduler afterwards)
20 x silence = 10 hours
"""
for i in range (0, 1):
ls_playlist += self.silence_file + "\n"
print '',
# write playlist file
plfile = open(self.cache_dir + str(pkey) + '/list.lsp', "w")
plfile.write(ls_playlist)
plfile.close()
logger.info('ls playlist file written to %s', self.cache_dir + str(pkey) + '/list.lsp')
except Exception, e:
logger.info("%s", e)
def handle_live_session(self, playlist, pkey, ls_playlist):
"""
This is a live session, so silence is scheduled.
Maybe not the most elegant solution :)
It adds 20 times 30min silence to the playlist
Silence file has to be in <file_dir>/basic/silence.mp3
"""
logger = logging.getLogger()
logger.debug("found %s seconds of live/studio session at %s", pkey, playlist['duration'])
if os.path.isfile(self.silence_file):
logger.debug('file stored at: %s' + self.silence_file)
for i in range (0, 19):
ls_playlist += self.silence_file + "\n"
else:
print 'Could not find silence file!'
print 'File is expected to be at: ' + self.silence_file
logger.critical('File is expected to be at: %s', self.silence_file)
sys.exit()
return ls_playlist
def handle_live_cast(self, playlist, pkey, ls_playlist):
"""
This is a live-cast session
Create a silence list. (could eg also be a fallback list..)
"""
logger = logging.getLogger()
logger.debug("found %s seconds of live-cast session at %s", pkey, playlist['duration'])
if os.path.isfile(self.silence_file):
logger.debug('file stored at: %s' + self.silence_file)
for i in range (0, 19):
ls_playlist += self.silence_file + "\n"
else:
print 'Could not find silence file!'
print 'File is expected to be at: ' + self.silence_file
logger.critical('File is expected to be at: %s', self.silence_file)
sys.exit()
return ls_playlist
def handle_media_file(self, playlist, pkey, ls_playlist):
"""
This handles both remote and local files.
Returns an updated ls_playlist string.
"""
logger = logging.getLogger()
for media in playlist['medias']:
logger.debug("Processing track %s", media['uri'])
try:
if str(media['cue_in']) == '0' and str(media['cue_out']) == '0':
logger.debug('No cue in/out detected for this file')
dst = "%s%s/%s.mp3" % (self.cache_dir, str(pkey), str(media['id']))
do_cue = False
else:
logger.debug('Cue in/out detected')
dst = "%s%s/%s_cue_%s-%s.mp3" % \
(self.cache_dir, str(pkey), str(media['id']), str(float(media['cue_in']) / 1000), str(float(media['cue_out']) / 1000))
do_cue = True
# check if it is a remote file, if yes download
if media['uri'][0:4] == 'http':
self.handle_remote_file(media, dst, do_cue)
else:
# Assume local file
self.handle_local_file(media, dst, do_cue)
if True == os.access(dst, os.R_OK):
# check filesize (avoid zero-byte files)
try: fsize = os.path.getsize(dst)
except Exception, e:
logger.error("%s", e)
fsize = 0
if fsize > 0:
pl_entry = 'annotate:export_source="%s",media_id="%s",liq_start_next="%s",liq_fade_in="%s",liq_fade_out="%s":%s' % \
(str(media['export_source']), media['id'], 0, str(float(media['fade_in']) / 1000), str(float(media['fade_out']) / 1000), dst)
logger.debug(pl_entry)
"""
Tracks are only added to the playlist if they are accessible
on the file system and larger than 0 bytes.
So this can lead to playlists shorter than expectet.
(there is a hardware silence detector for this cases...)
"""
ls_playlist += pl_entry + "\n"
logger.debug("everything ok, adding %s to playlist", pl_entry)
else:
print 'zero-file: ' + dst + ' from ' + media['uri']
logger.warning("zero-size file - skiping %s. will not add it to playlist", dst)
else:
logger.warning("something went wrong. file %s not available. will not add it to playlist", dst)
except Exception, e: logger.info("%s", e)
return ls_playlist
def handle_remote_file(self, media, dst, do_cue):
logger = logging.getLogger()
if do_cue == False:
if os.path.isfile(dst):
logger.debug("file already in cache: %s", dst)
else:
logger.debug("try to download %s", media['uri'])
self.api_client.get_media(media['uri'], dst)
else:
if os.path.isfile(dst):
logger.debug("file already in cache: %s", dst)
else:
logger.debug("try to download and cue %s", media['uri'])
dst_tmp = config["tmp_dir"] + "".join([random.choice(string.letters) for i in xrange(10)]) + '.mp3'
self.api_client.get_media(media['uri'], dst_tmp)
# cue
logger.debug("STARTING CUE")
debugDst = self.cue_file.cue(dst_tmp, dst, float(media['cue_in']) / 1000, float(media['cue_out']) / 1000)
logger.debug(debugDst)
logger.debug("END CUE")
if True == os.access(dst, os.R_OK):
try: fsize = os.path.getsize(dst)
except Exception, e:
logger.error("%s", e)
fsize = 0
if fsize > 0:
logger.debug('try to remove temporary file: %s' + dst_tmp)
try: os.remove(dst_tmp)
except Exception, e:
logger.error("%s", e)
else:
logger.warning('something went wrong cueing: %s - using uncued file' + dst)
try: os.rename(dst_tmp, dst)
except Exception, e:
logger.error("%s", e)
def handle_local_file(self, media, dst, do_cue):
"""
Handle files on NAS. Pre-cueing not implemented at the moment.
(not needed by openbroadcast, feel free to add this)
Here an implementation for localy stored files.
Works the same as with remote files, just replaced API-download with
file copy.
"""
logger = logging.getLogger()
if do_cue == False:
if os.path.isfile(dst):
logger.debug("file already in cache: %s", dst)
else:
logger.debug("try to copy file to cache %s", media['uri'])
try:
shutil.copy(media['uri'], dst)
logger.info("copied %s to %s", media['uri'], dst)
except Exception, e:
logger.error("%s", e)
else:
if os.path.isfile(dst):
logger.debug("file already in cache: %s", dst)
else:
logger.debug("try to copy and cue %s", media['uri'])
print '***'
dst_tmp = config["tmp_dir"] + "".join([random.choice(string.letters) for i in xrange(10)])
print dst_tmp
print '***'
try:
shutil.copy(media['uri'], dst_tmp)
logger.info("copied %s to %s", media['uri'], dst_tmp)
except Exception, e:
logger.error("%s", e)
# cue
print "STARTIONG CUE"
print self.cue_file.cue(dst_tmp, dst, float(media['cue_in']) / 1000, float(media['cue_out']) / 1000)
print "END CUE"
if True == os.access(dst, os.R_OK):
try: fsize = os.path.getsize(dst)
except Exception, e:
logger.error("%s", e)
fsize = 0
if fsize > 0:
logger.debug('try to remove temporary file: %s' + dst_tmp)
try: os.remove(dst_tmp)
except Exception, e:
logger.error("%s", e)
else:
logger.warning('something went wrong cueing: %s - using uncued file' + dst)
try: os.rename(dst_tmp, dst)
except Exception, e:
logger.error("%s", e)
def cleanup(self, export_source):
"""
Cleans up folders in cache_dir. Look for modification date older than "now - CACHE_FOR"
and deletes them.
"""
logger = logging.getLogger()
self.set_export_source(export_source)
offset = 3600 * int(config["cache_for"])
now = time.time()
for r, d, f in os.walk(self.cache_dir):
for dir in d:
try:
timestamp = time.mktime(time.strptime(dir, "%Y-%m-%d-%H-%M-%S"))
#logger.debug('dir : %s', (dir))
#logger.debug('age : %s', (round((now - timestamp),1)))
#logger.debug('delete in : %ss', (round((offset - (now - timestamp)),1)))
#logger.debug('Folder "Age": %s - %s', round((((now - offset) - timestamp) / 60), 2), os.path.join(r, dir))
if (now - timestamp) > offset:
try:
logger.debug('trying to remove %s - timestamp: %s', os.path.join(r, dir), timestamp)
shutil.rmtree(os.path.join(r, dir))
except Exception, e:
logger.error("%s", e)
pass
else:
logger.info('sucessfully removed %s', os.path.join(r, dir))
except Exception, e:
print e
logger.error("%s", e)
"""
The Push Loop - the push loop periodically (minimal 1/2 of the playlist-grid)
checks if there is a playlist that should be scheduled at the current time.
If yes, the temporary liquidsoap playlist gets replaced with the corresponding one,
then liquidsoap is asked (via telnet) to reload and immediately play it.
"""
def push(self, export_source):
logger = logging.getLogger()
self.set_export_source(export_source)
#try:
# dummy = self.schedule
# logger.debug('schedule already loaded')
#except Exception, e:
# self.schedule = self.push_init(self.export_source)
self.schedule = self.load_schedule()
playedItems = self.load_schedule_tracker()
tcomming = time.localtime(time.time() + self.push_ahead)
tnow = time.localtime(time.time())
str_tnow = "%04d-%02d-%02d-%02d-%02d" % (tnow[0], tnow[1], tnow[2], tnow[3], tnow[4])
str_tnow_s = "%04d-%02d-%02d-%02d-%02d-%02d" % (tnow[0], tnow[1], tnow[2], tnow[3], tnow[4], tnow[5])
str_tcomming = "%04d-%02d-%02d-%02d-%02d" % (tcomming[0], tcomming[1], tcomming[2], tcomming[3], tcomming[4])
str_tcomming_s = "%04d-%02d-%02d-%02d-%02d-%02d" % (tcomming[0], tcomming[1], tcomming[2], tcomming[3], tcomming[4], tcomming[5])
playnow = None
if self.schedule == None:
logger.warn('Unable to loop schedule - maybe write in progress?')
logger.warn('Will try again in next loop.')
else:
for pkey in self.schedule:
if pkey[0:16] == str_tcomming:
logger.debug('Preparing to push playlist scheduled at: %s', pkey)
playlist = self.schedule[pkey]
playedFlag = (pkey in playedItems) and playedItems[pkey].get("played", 0)
logger.debug("PLAYED FLAG: " + str(playedFlag))
if not playedFlag:
# We have a match, replace the current playlist and
# force liquidsoap to refresh.
ptype = playlist['subtype']
if (self.push_liquidsoap(pkey, self.schedule, ptype) == 1):
logger.debug("Pushed to liquidsoap, updating 'played' status.")
# Marked the current playlist as 'played' in the schedule tracker
# so it is not called again in the next push loop.
# Write changes back to tracker file.
playedItems[pkey] = playlist
playedItems[pkey]['played'] = 1
schedule_tracker = open(self.schedule_tracker_file, "w")
pickle.dump(playedItems, schedule_tracker)
schedule_tracker.close()
logger.debug("Wrote schedule to disk: "+str(playedItems))
# Call API to update schedule states
logger.debug("Doing callback to server to update 'played' status.")
self.api_client.notify_scheduled_item_start_playing(pkey, self.schedule)
def load_schedule(self):
logger = logging.getLogger()
schedule = None
# create the file if it doesnt exist
if (not os.path.exists(self.schedule_file)):
logger.debug('creating file ' + self.schedule_file)
open(self.schedule_file, 'w').close()
else:
# load the schedule from cache
logger.debug('loading schedule file '+self.schedule_file)
try:
schedule_file = open(self.schedule_file, "r")
schedule = pickle.load(schedule_file)
schedule_file.close()
except Exception, e:
logger.error('%s', e)
return schedule
def load_schedule_tracker(self):
logger = logging.getLogger()
playedItems = dict()
# create the file if it doesnt exist
if (not os.path.exists(self.schedule_tracker_file)):
logger.debug('creating file ' + self.schedule_tracker_file)
schedule_tracker = open(self.schedule_tracker_file, 'w')
pickle.dump(playedItems, schedule_tracker)
schedule_tracker.close()
else:
try:
logger.debug('loading schedule tracker file '+ self.schedule_tracker_file)
schedule_tracker = open(self.schedule_tracker_file, "r")
playedItems = pickle.load(schedule_tracker)
schedule_tracker.close()
except Exception, e:
logger.error('Unable to load schedule tracker file: %s', e)
return playedItems
def push_liquidsoap(self, pkey, schedule, ptype):
logger = logging.getLogger()
src = self.cache_dir + str(pkey) + '/list.lsp'
try:
if True == os.access(src, os.R_OK):
logger.debug('OK - Can read playlist file')
pl_file = open(src, "r")
"""
i know this could be wrapped, maybe later..
"""
tn = telnetlib.Telnet(LS_HOST, 1234)
if (int(ptype) == 6):
tn.write("live_in.start")
tn.write("\n")
if (int(ptype) < 5):
for line in pl_file.readlines():
logger.debug(line.strip())
tn.write(self.export_source + '.push %s' % (line.strip()))
tn.write("\n")
#time.sleep(0.1)
tn.write("exit\n")
logger.debug(tn.read_all())
logger.debug('sleeping for %s s' % (self.push_ahead))
time.sleep(self.push_ahead)
logger.debug('sending "flip"')
tn = telnetlib.Telnet(LS_HOST, 1234)
# Get any extra information for liquidsoap (which will be sent back to us)
liquidsoap_data = self.api_client.get_liquidsoap_data(pkey, schedule)
logger.debug("Sending additional data to liquidsoap: "+liquidsoap_data)
tn.write("vars.pypo_data "+liquidsoap_data+"\n")
# if(int(ptype) < 5):
# tn.write(self.export_source + '.flip')
# tn.write("\n")
tn.write(self.export_source + '.flip')
tn.write("\n")
if (int(ptype) == 6):
tn.write("live.active 1")
tn.write("\n")
else:
tn.write("live.active 0")
tn.write("\n")
tn.write("live_in.stop")
tn.write("\n")
tn.write("exit\n")
tn.read_all()
status = 1
except Exception, e:
logger.error('%s', e)
status = 0
return status
#def push_liquidsoap_legacy(self, pkey, ptype, p_id, user_id):
# logger = logging.getLogger()
# logger.debug('trying to push %s to liquidsoap', pkey)
#
# self.export_source = export_source
# self.cache_dir = CACHE_DIR + self.export_source + '/'
# self.schedule_file = self.cache_dir + 'schedule'
#
# src = self.cache_dir + str(pkey) + '/list.lsp'
# dst = self.cache_dir + 'current.lsp'
#
# print src
# print dst
#
# print '*************'
# print ptype
# print '*************'
#
# if True == os.access(src, os.R_OK):
# try:
# shutil.copy2(src, dst)
# logger.debug('copy %s to %s', src, dst)
# """
# i know this could be wrapped, maybe later..
# """
# tn = telnetlib.Telnet(LS_HOST, 1234)
# tn.write("\n")
# tn.write("live_in.stop\n")
# tn.write("stream_disable\n")
# time.sleep(0.2)
# tn.write("\n")
# #tn.write("reload_current\n")
# tn.write("current.reload\n")
# time.sleep(0.2)
# tn.write("skip_current\n")
#
# if(int(ptype) == 6):
# """
# Couchcaster comming. Stop/Start live input to have ls re-read it's playlist
# """
# print 'Couchcaster - switching to stream'
# tn.write("live_in.start\n")
# time.sleep(0.2)
# tn.write("stream_enable\n")
#
# if(int(ptype) == 7):
# """
# Recast comming. Start the live input
# """
# print 'Recast - switching to stream'
# tn.write("live_in.start\n")
# time.sleep(0.2)
# tn.write("stream_enable\n")
#
# """
# Pass some extra information to liquidsoap
# """
# tn.write("pl.pl_id '%s'\n" % p_id)
# tn.write("pl.user_id '%s'\n" % user_id)
# tn.write("exit\n")
#
# print tn.read_all()
#
# status = 1
#
# except Exception, e:
# logger.error('%s', e)
# status = 0
# else:
# status = 0
#
# return status
"""
Updates the jingles. Give comma separated list of jingle tracks.
NOTE: commented out because it needs to be converted to use the API client. - Paul
"""
#def update_jingles(self, options):
# print 'jingles'
#
# jingle_list = string.split(options, ',')
# print jingle_list
# for media_id in jingle_list:
# # api path maybe should not be hard-coded
# src = API_BASE + 'api/pypo/get_media/' + str(media_id)
# print src
# # include the hourly jungles for the moment
# dst = "%s%s/%s.mp3" % (config["file_dir"], 'jingles/hourly', str(media_id))
# print dst
#
# try:
# print '** urllib auth with: ',
# print self.api_auth
# opener = urllib.URLopener()
# opener.retrieve (src, dst, False, self.api_auth)
# logger.info("downloaded %s to %s", src, dst)
# except Exception, e:
# print e
# logger.error("%s", e)
def check_schedule(self, export_source):
logger = logging.getLogger()
self.set_export_source(export_source)
try:
schedule_file = open(self.schedule_file, "r")
schedule = pickle.load(schedule_file)
schedule_file.close()
except Exception, e:
logger.error("%s", e)
schedule = None
for pkey in sorted(schedule.iterkeys()):
playlist = schedule[pkey]
print '*****************************************'
print '\033[0;32m%s %s\033[m' % ('scheduled at:', str(pkey))
print 'cached at : ' + self.cache_dir + str(pkey)
print 'subtype: ' + str(playlist['subtype'])
print 'played: ' + str(playlist['played'])
print 'schedule id: ' + str(playlist['schedule_id'])
print 'duration: ' + str(playlist['duration'])
print 'source id: ' + str(playlist['x_ident'])
print '-----------------------------------------'
for media in playlist['medias']:
print media
print
if __name__ == '__main__':
print
print '###########################################'
print '# *** pypo *** #'
print '# Liquidsoap + External Scheduler #'
print '# Playout System #'
print '###########################################'
print
# initialize
g = Global()
g.selfcheck()
po = Playout()
run = True
while run == True:
logger = logging.getLogger()
loops = 0
if options.test:
po.test_api()
sys.exit()
while options.fetch_scheduler:
try: po.fetch('scheduler')
except Exception, e:
print e
sys.exit()
print 'ZZzZzZzzzzZZZz.... sleeping for ' + str(POLL_INTERVAL) + ' seconds'
logger.info('fetch loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, POLL_INTERVAL)
loops += 1
time.sleep(POLL_INTERVAL)
while options.fetch_daypart:
try: po.fetch('daypart')
except Exception, e:
print e
sys.exit()
print 'ZZzZzZzzzzZZZz.... sleeping for ' + str(POLL_INTERVAL) + ' seconds'
logger.info('fetch loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, POLL_INTERVAL)
loops += 1
time.sleep(POLL_INTERVAL)
while options.push_scheduler:
po.push('scheduler')
try: po.push('scheduler')
except Exception, e:
print 'PUSH ERROR!! WILL EXIT NOW:('
print e
sys.exit()
logger.info('push loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, PUSH_INTERVAL)
loops += 1
time.sleep(PUSH_INTERVAL)
while options.push_daypart:
po.push('daypart')
try: po.push('daypart')
except Exception, e:
print 'PUSH ERROR!! WILL EXIT NOW:('
print e
sys.exit()
logger.info('push loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, PUSH_INTERVAL)
loops += 1
time.sleep(PUSH_INTERVAL)
#while options.jingles:
# try: po.update_jingles(options.jingles)
# except Exception, e:
# print e
# sys.exit()
while options.check:
try: po.check_schedule()
except Exception, e:
print e
sys.exit()
while options.cleanup:
try: po.cleanup('scheduler')
except Exception, e:
print e
sys.exit()
sys.exit()

195
pypo/pypo_dls.py Executable file
View file

@ -0,0 +1,195 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Python part of radio playout (pypo)
This function acts as a gateway between liquidsoap and the obp-api.
Mainliy used to tell the platform what pypo/LS does.
Main case:
- whenever Liquidsoap starts playing a new track, its on_metadata callback calls
a function in liquidsoap (notify(m)) which then calls the python script here
with the currently starting filename as parameter
- this python script takes this parameter, tries to extract the actual
media id from it, and then calls back to API to tell it about it.
"""
# python defaults (debian default)
import time
import os
import traceback
from optparse import *
import sys
import time
import datetime
import logging
import logging.config
import urllib
import urllib2
import string
import socket
# additional modules (should be checked)
from configobj import ConfigObj
# custom imports
from util import *
from obp import *
PYPO_VERSION = '0.9'
#set up command-line options
parser = OptionParser()
# help screeen / info
usage = "%prog [options]" + " - notification gateway"
parser = OptionParser(usage=usage)
#options
parser.add_option("-p", "--playing", help="Tell daddy what is playing right now", metavar="path")
# parse options
(options, args) = parser.parse_args()
# configure logging
logging.config.fileConfig("logging.cfg")
# loading config file
try:
config = ConfigObj('config.cfg')
TMP_DIR = config['tmp_dir']
BASE_URL = config['base_url']
API_BASE = BASE_URL + 'mod/medialibrary/'
EXPORT_SOURCE = config['export_source']
API_KEY = config['api_key']
except Exception, e:
print 'error: ', e
sys.exit()
class Global:
def __init__(self):
print
def selfcheck(self):
self.api_auth = urllib.urlencode({'api_key': API_KEY})
self.api_client = api_client.api_client_factory(config)
self.api_client.check_version()
class Notify:
def __init__(self):
self.tmp_dir = TMP_DIR
self.export_source = EXPORT_SOURCE
self.api_auth = urllib.urlencode({'api_key': API_KEY})
self.api_client = api_client.api_client_factory(config)
def start_playing(self, options):
logger = logging.getLogger("start_playing")
tnow = time.localtime(time.time())
path = options
try:
file = path.split("/")[-1:][0]
if file.find('_cue_') > 0:
id = file.split("_cue_")[0]
else:
id = file.split(".")[-2:][0]
except Exception, e:
#print e
id = False
try:
id = int(id)
except Exception, e:
#print e
id = False
print
print "Media ID: ",
print id
# self.api_client.update_start_playing(id, self.export_source, path)
txt = "test this update"
# Echo client program
HOST = '172.16.16.128' # The remote host
PORT = 50008 # The same port as used by the server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.send('client_zzzz')
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('RS_DLS_VERSION' + ' ' + '1')
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('SERVICE' + ' ' + 'OPENBRO+')
s.send("\r\n")
s.send('PASSWORD' + ' ' + 'OPENBRO+')
s.send("\r\n")
data = s.recv(1024)
print data;
s.send('CLEAR_DLS')
s.send("\r\n")
s.send('SET_DLS' + ' ' + txt)
s.send("\r\n")
data = s.recv(1024)
print data;
s.close()
print data
if data == "session":
print 'KKK'
time.sleep(0.1)
print 'DONE'
if __name__ == '__main__':
print
print '#########################################'
print '# *** pypo *** #'
print '# pypo notification gateway #'
print '#########################################'
print
# initialize
g = Global()
g.selfcheck()
n = Notify()
run = True
while run == True:
logger = logging.getLogger("pypo notify")
while options.playing:
try: n.start_playing(options.playing)
except Exception, e:
print e
sys.exit()
sys.exit()

233
pypo/pypo_notify.py Executable file
View file

@ -0,0 +1,233 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Python part of radio playout (pypo)
This function acts as a gateway between liquidsoap and the server API.
Mainly used to tell the platform what pypo/liquidsoap does.
Main case:
- whenever LS starts playing a new track, its on_metadata callback calls
a function in ls (notify(m)) which then calls the python script here
with the currently starting filename as parameter
- this python script takes this parameter, tries to extract the actual
media id from it, and then calls back to the API to tell about it about it.
"""
# python defaults (debian default)
import time
import os
import traceback
from optparse import *
import sys
import time
import datetime
import logging
import logging.config
import urllib
import urllib2
import string
# additional modules (should be checked)
from configobj import ConfigObj
# custom imports
from util import *
from api_clients import *
from dls import *
PYPO_VERSION = '0.9'
# Set up command-line options
parser = OptionParser()
# help screeen / info
usage = "%prog [options]" + " - notification gateway"
parser = OptionParser(usage=usage)
# Options
parser.add_option("-d", "--data", help="Pass JSON data from liquidsoap into this script.", metavar="data")
#parser.add_option("-p", "--playing", help="Tell server what is playing right now.", default=False, action="store_true", dest="playing")
#parser.add_option("-t", "--playlist-type", help="", metavar="playlist_type")
parser.add_option("-m", "--media-id", help="ID of the file that is currently playing.", metavar="media_id")
#parser.add_option("-U", "--user-id", help="", metavar="user_id")
#parser.add_option("-P", "--playlist-id", help="", metavar="playlist_id")
#parser.add_option("-T", "--transmission-id", help="", metavar="transmission_id")
#parser.add_option("-E", "--export-source", help="", metavar="export_source")
# parse options
(options, args) = parser.parse_args()
# configure logging
logging.config.fileConfig("logging.cfg")
# loading config file
try:
config = ConfigObj('config.cfg')
except Exception, e:
print 'error: ', e
sys.exit()
class Global:
def __init__(self):
print
def selfcheck(self):
pass
#self.api_client = api_client.api_client_factory(config)
#self.api_client.check_version()
class Notify:
def __init__(self):
self.api_client = api_client.api_client_factory(config)
#self.dls_client = DlsClient('127.0.0.128', 50008, 'myusername', 'mypass')
def notify_media_start_playing(self, data, media_id):
logger = logging.getLogger()
#tnow = time.localtime(time.time())
logger.debug('#################################################')
logger.debug('# Calling server to update about what\'s playing #')
logger.debug('#################################################')
logger.debug('data = '+ str(data))
#print 'options.data = '+ options.data
#data = json.read(options.data)
response = self.api_client.notify_media_item_start_playing(data, media_id)
logger.debug("Response: "+str(response))
#def start_playing(self, options):
# logger = logging.getLogger("start_playing")
# tnow = time.localtime(time.time())
#
# #print options
#
# logger.debug('#################################################')
# logger.debug('# Calling server to update about what\'s playing #')
# logger.debug('#################################################')
#
# if int(options.playlist_type) < 5:
# logger.debug('seems to be a playlist')
#
# try:
# media_id = int(options.media_id)
# except Exception, e:
# media_id = 0
#
# response = self.api_client.update_start_playing(options.playlist_type, options.export_source, media_id, options.playlist_id, options.transmission_id)
#
# logger.debug(response)
#
# if int(options.playlist_type) == 6:
# logger.debug('seems to be a couchcast')
#
# try:
# media_id = int(options.media_id)
# except Exception, e:
# media_id = 0
#
# response = self.api_client.update_start_playing(options.playlist_type, options.export_source, media_id, options.playlist_id, options.transmission_id)
#
# logger.debug(response)
#
# sys.exit()
#def start_playing_legacy(self, options):
# logger = logging.getLogger("start_playing")
# tnow = time.localtime(time.time())
#
# print '#################################################'
# print '# Calling server to update about what\'s playing #'
# print '#################################################'
#
# path = options
#
# print
# print path
# print
#
# if 'pl_id' in path:
# print 'seems to be a playlist'
# type = 'playlist'
# id = path[5:]
#
# elif 'text' in path:
# print 'seems to be a playlist'
# type = 'text'
# id = path[4:]
# print id
#
# else:
# print 'seems to be a single track (media)'
# type = 'media'
# try:
# file = path.split("/")[-1:][0]
# if file.find('_cue_') > 0:
# id = file.split("_cue_")[0]
# else:
# id = file.split(".")[-2:][0]
#
# except Exception, e:
# #print e
# id = False
#
# try:
# id = id
# except Exception, e:
# #print e
# id = False
#
# print
# print type + " id: ",
# print id
#
#
# response = self.api_client.update_start_playing(type, id, self.export_source, path)
#
# print 'DONE'
#
# try:
# txt = response['txt']
# print '#######################################'
# print txt
# print '#######################################'
# #self.dls_client.set_txt(txt)
#
# except Exception, e:
# print e
if __name__ == '__main__':
print
print '#########################################'
print '# *** pypo *** #'
print '# pypo notification gateway #'
print '#########################################'
# initialize
g = Global()
logger = logging.getLogger()
#if options.playing:
# try: n.start_playing(options)
# except Exception, e:
# print e
# sys.exit()
if not options.data:
print "NOTICE: 'data' command-line argument not given."
sys.exit()
if not options.media_id:
print "NOTICE: 'media_id' command-line argument not given."
sys.exit()
try:
g.selfcheck()
n = Notify()
n.notify_media_start_playing(options.data, options.media_id)
except Exception, e:
print e

23
pypo/scripts/README Normal file
View file

@ -0,0 +1,23 @@
This directory contains scripts not directly related to pypo
These mainly are things related to liquidsoap & playout
I added those scripts here to have them at hand for
development and also to update/share them via svn
scripts here:
- ls_run.sh
wrapper to run liquid soap. makes sure that the "current" playlist is
filled with silence
- ls_script.liq (called by ls_run.sh)
the main liquidsoap control-script
- ls_cue.liq (included by ls_script.liq)
contains a custom protocol that registers the cue-in/out values from the playlist script
- cue_file.py (called by ls_cue.liq)
a wrapper that does the actual cutting.
it is called with: path_to_file[path] cue_in[ss.ms] cue_out[ss.ms] and does the mp3 cutting (with mp3cut)
returns a temporary file that can be used by ls (make sure to set "TEMP_DIR" in script)

125
pypo/scripts/cue_file.py Executable file
View file

@ -0,0 +1,125 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
cue script that gets called by liquidsoap if a file in the playlist
gives orders to cue (in/out). eg:
cue_file:cue_in=120.0,cue_out=110.0:annotate:***
params: path_to_file, cue_in [float, seconds], cue_out [float, sseconds]
returns: path to the cued temp-file
examples:
calling: ./cue_file.py /storage/pypo/cache/2010-06-25-15-05-00/35.mp3 10 120.095
returns: /tmp/lstf_UwDKcEngvF
One thing to mention here:
The way pypo (ab)uses liquidsoap can bring in some unwanted effects. liquidsoap
is built in a way that it tries to collect the needed files to playout in advance.
we 'force' liquidsoap to immediately start playing a newly loaded list, so ls has
no time to prepare the files. If a file is played without cues, this does not afect
the playout too much. My testing on a lame VM added a delay of +/- 10ms.
If the first file in a playlist is cued, the "mp3cut" command takes time to execute.
On the same VM this takes an additional 200ms for an average size mp3-file.
So the playout will start a bit delayed. This should not be a too big issue, but
think about this behaviour if you eg access the files via network (nas) as the reading
of files could take some time as well.
So maybe we should think about a different implementation. One way would be to do the
cueing during playlist preparation, so all the files would be pre-cut when they are
passed to liquidsoap.
Additionally this would allow to run an unpathed version of ls.
"""
import sys
import shutil
import random
import string
import time
from datetime import timedelta
import os
from mutagen.mp3 import MP3
import mad
TEMP_DIR = '/tmp/';
sys.stderr.write('\n** starting mp3 cutter **\n\n')
try: src = sys.argv[1]
except Exception, e:
sys.stderr.write('No file givien. sorry.\n')
sys.exit()
try: cue_in = float(sys.argv[2])
except Exception, e:
cue_in = float(0)
pass
try: cue_out = float(sys.argv[3])
except Exception, e:
cue_out = float(0)
pass
sys.stderr.write('in: %s - out: %s file: %s \n' % (cue_in, cue_out, src))
dst = TEMP_DIR + 'lstf_' + "".join( [random.choice(string.letters) for i in xrange(10)] )
# get length of track
"""
madlib is not accurate enough to get the duration. (only goes to seconds, no ms)
so it is not suitable for relative offsets (eg "play until 10s before the end")
it anyway wuld be better to provide this script with absolute times, like
play from 23.234 to 323.321
"""
# madlib
#mf = mad.MadFile(src)
#dur = float(float(mf.total_time())/1000)
# mutagen
audio = MP3(src)
dur = round(audio.info.length, 3)
sys.stderr.write('duration: ' + str(dur) + '\n')
cue_out = round(float(dur) - cue_out, 3)
str_cue_in = str(timedelta(seconds=cue_in)).replace(".", "+") # hh:mm:ss+mss, eg 00:00:20+000
str_cue_out = str(timedelta(seconds=cue_out)).replace(".", "+") #
"""
now a bit a hackish part, don't know how to do this better...
need to cut the digits after the "+"
"""
ts = str_cue_in.split("+")
try:
if len(ts[1]) == 6:
ts[1] = ts[1][0:3]
str_cue_in = "%s+%s" % (ts[0], ts[1])
except Exception, e:
pass
ts = str_cue_out.split("+")
try:
if len(ts[1]) == 6:
ts[1] = ts[1][0:3]
str_cue_out = "%s+%s" % (ts[0], ts[1])
except Exception, e:
pass
#sys.stderr.write(str(timedelta(seconds=cue_in)).replace(".", "+") + '\n\n')
sys.stderr.write('in: ' + str_cue_in + '\n')
sys.stderr.write('abs: ' + str(str_cue_out) + '\n\n')
command = 'mp3cut -o %s -t %s-%s %s' % (dst, str_cue_in, str_cue_out, src);
sys.stderr.write(command + '\n\n\n')
os.system(command + ' >/dev/null')
#shutil.copy2(src, dst)
print dst + "\n";

70
pypo/scripts/include_daypart.liq Normal file
View file

@ -0,0 +1,70 @@
#########################################
# A/B queue-setup daypart
#########################################
# a/b queue setup
daypart_q0 = request.queue(conservative=true,length=600.,id="daypart_q0")
daypart_q1 = request.queue(conservative=true,length=600.,id="daypart_q1")
daypart_q0 = audio_to_stereo(daypart_q0)
daypart_q1 = audio_to_stereo(daypart_q1)
daypart_active = ref 0
daypart_queue = ref 1
daypart_q0_enabled = ref false
daypart_q1_enabled = ref false
# push function, enqueues file in inactive queue (does not start automatically)
def daypart_push(s)
list.hd(server.execute("daypart_q#{!daypart_queue}.push #{s}"))
print('push to #{!daypart_queue} - #{s}')
"Done"
end
# flips the queues
def daypart_flip()
# set a/b-queue corresponding to active, see fallback below
if !daypart_active==1 then daypart_q0_enabled:=true else daypart_q0_enabled:=false end
if !daypart_active==0 then daypart_q1_enabled:=true else daypart_q1_enabled:=false end
# get playing (active) queue and flush it
l = list.hd(server.execute("daypart_q#{!daypart_active}.queue"))
l = string.split(separator=" ",l)
list.iter(fun (rid) -> ignore(server.execute("daypart_q#{!daypart_active}.ignore #{rid}")), l)
# skip the playing item
# source.skip(if !daypart_active==0 then daypart_q0 else daypart_q1 end)
# flip variables
daypart_active := 1-!daypart_active
daypart_queue := 1-!daypart_active
"Done"
end
# print status
def daypart_status()
print('daypart_active: #{!daypart_active}')
print('daypart_queue : #{!daypart_queue}')
"Done"
end
# register for telnet access
server.register(namespace="daypart","push", daypart_push)
server.register(namespace="daypart","flip", fun (_) -> daypart_flip())
server.register(namespace="daypart","status", fun (_) -> daypart_status())
# activate / deactivate queues, needed for fallback to work
daypart_q0 = switch(track_sensitive=true, [({!daypart_q0_enabled},daypart_q0)])
daypart_q1 = switch(track_sensitive=true, [({!daypart_q1_enabled},daypart_q1)])
daypart_q_holder = fallback(track_sensitive=true, [daypart_q0, daypart_q1])
# finally the resulting daypart source
daypart = fallback(track_sensitive=false, [daypart_q_holder, default])

37
pypo/scripts/include_dynamic_vars.liq Normal file
View file

@ -0,0 +1,37 @@
#######################################################################
# Dynamic variables
#######################################################################
playlist_id = ref '0'
user_id = ref '0'
transmission_id = ref '0'
playlist_type = ref '0'
pypo_data = ref '0'
def set_pypo_data(s)
pypo_data := s
end
def set_user_id(s)
user_id := s
end
def set_playlist_id(s)
playlist_id := s
end
def set_transmission_id(s)
transmission_id := s
end
def set_playlist_type(s)
playlist_type := s
end
server.register(namespace="vars", "user_id", fun (s) -> begin set_user_id(s) "Done!" end)
server.register(namespace="vars", "playlist_id", fun (s) -> begin set_playlist_id(s) "Done!" end)
server.register(namespace="vars", "transmission_id", fun (s) -> begin set_transmission_id(s) "Done!" end)
server.register(namespace="vars", "playlist_type", fun (s) -> begin set_playlist_type(s) "Done!" end)
server.register(namespace="vars", "pypo_data", fun (s) -> begin set_pypo_data(s) "Done!" end)

24
pypo/scripts/include_live_in.liq Normal file
View file

@ -0,0 +1,24 @@
#######################################################################
# Live input - From external icecast server
#######################################################################
live_in = input.http(id="live_in",autostart=false,buffer=.1, max=12.,couchcaster_list)
live_in = buffer(id="buffer_live_in",buffer=.1,fallible=true,live_in)
live_in = mksafe(live_in)
live_active = ref false
def live_switch(i)
print(i)
if i=='1' then live_active:=true else live_active:=false end
print(live_active)
"Done"
end
server.register(namespace="live","active", live_switch)
live = switch(track_sensitive=false, [({!live_active},live_in)])
to_live_s = to_live(jingles_cc)
to_scheduler_s = to_scheduler()

28
pypo/scripts/include_notify.liq Normal file
View file

@ -0,0 +1,28 @@
########################################
# call pypo api gateway
########################################
def notify(m)
# print('user_id: #{!user_id}')
# print('playlist_id: #{!playlist_id}')
# print('transmission_id: #{!transmission_id}')
# print('playlist_type: #{!playlist_type}')
if !playlist_type=='5' then
print('livesession')
system("./notify.sh --playing --playlist-type=#{!playlist_type} --transmission-id=#{!transmission_id} --export-source=scheduler")
end
if !playlist_type=='6' then
print('couchcaster')
system("./notify.sh --playing --playlist-type=#{!playlist_type} --transmission-id=#{!transmission_id} --export-source=scheduler")
end
if !playlist_type=='0' or !playlist_type=='1' or !playlist_type=='2' or !playlist_type=='3' or !playlist_type=='4' then
print('include_notify.liq: notify on playlist')
#system("./notify.sh --playing --playlist-type=#{!playlist_type} --media-id=#{m['media_id']} --export-source=#{m['export_source']}")
system("./notify.sh --data='#{!pypo_data}' --media-id=#{m['media_id']}")
end
end

77
pypo/scripts/include_scheduler.liq Normal file
View file

@ -0,0 +1,77 @@
#########################################
# A/B queue-setup Scheduler
#########################################
# a/b queue setup
scheduler_q0 = request.queue(conservative=true,length=600.,id="scheduler_q0")
scheduler_q1 = request.queue(conservative=true,length=600.,id="scheduler_q1")
scheduler_q0 = audio_to_stereo(scheduler_q0)
scheduler_q1 = audio_to_stereo(scheduler_q1)
scheduler_active = ref 0
scheduler_queue = ref 1
scheduler_q0_enabled = ref false
scheduler_q1_enabled = ref false
# push function, enqueues file in inactive queue (does not start automatically)
def scheduler_push(s)
list.hd(server.execute("scheduler_q#{!scheduler_queue}.push #{s}"))
print('push to #{!scheduler_queue} - #{s}')
"Done"
end
# flips the queues
def scheduler_flip()
# set a/b-queue corresponding to active, see fallback below
if !scheduler_active==1 then scheduler_q0_enabled:=true else scheduler_q0_enabled:=false end
if !scheduler_active==0 then scheduler_q1_enabled:=true else scheduler_q1_enabled:=false end
# get playing (active) queue and flush it
l = list.hd(server.execute("scheduler_q#{!scheduler_active}.queue"))
l = string.split(separator=" ",l)
list.iter(fun (rid) -> ignore(server.execute("scheduler_q#{!scheduler_active}.ignore #{rid}")), l)
# skip the playing item
source.skip(if !scheduler_active==0 then scheduler_q0 else scheduler_q1 end)
# flip variables
scheduler_active := 1-!scheduler_active
scheduler_queue := 1-!scheduler_active
"Done"
end
# print status
def scheduler_status()
print('scheduler_active: #{!scheduler_active}')
print('scheduler_queue : #{!scheduler_queue}')
print('user_id: #{!user_id}')
print('playlist_id: #{!playlist_id}')
print('transmission_id: #{!transmission_id}')
print('playlist_type: #{!playlist_type}')
"Done"
end
# register for telnet access
server.register(namespace="scheduler","push", scheduler_push)
server.register(namespace="scheduler","flip", fun (_) -> scheduler_flip())
server.register(namespace="scheduler","status", fun (_) -> scheduler_status())
# activate / deactivate queues, needed for fallback to work
scheduler_q0 = switch(track_sensitive=true, [({!scheduler_q0_enabled},scheduler_q0)])
scheduler_q1 = switch(track_sensitive=true, [({!scheduler_q1_enabled},scheduler_q1)])
scheduler_q_holder = fallback(track_sensitive=true, [scheduler_q0, scheduler_q1])
# finally the resulting scheduler source
scheduler = fallback(track_sensitive=false, [scheduler_q_holder, default])

37
pypo/scripts/library.liq Normal file
View file

@ -0,0 +1,37 @@
# Define a transition that fades out the
# old source, adds a single, and then
# plays the new source
def to_live(jingle,old,new) =
# Fade out old source
old = fade.final(old)
# Supperpose the jingle
s = add([jingle,old])
# Compose this in sequence with
# the new source
sequence([s,new])
end
def to_scheduler(old,new) =
# We skip the file
# currently in new
# in order to being with
# a fresh file
# source.skip(new)
sequence([old,new])
end
# A transition when switching back to files:
def to_file(old,new) =
# We skip the file
# currently in new
# in order to being with
# a fresh file
# source.skip(new)
sequence([old,new])
end
def dp_to_scheduler(old,new) =
old = fade.final(type='log',duration=2.1,old)
sequence([old,new])
end

149
pypo/scripts/library/externals.liq Normal file
View file

@ -0,0 +1,149 @@
# Decoders, enabled when the binary is detected and the os is not Win32.
# Get_mime is not always defined
# so we define a default in this case..
my_get_mime = fun (_) -> ""
%ifdef get_mime
my_get_mime = get_mime
%endif
get_mime = my_get_mime
%ifdef add_decoder
if test_process("which flac") then
log(level=3,"Found flac binary: enabling flac external decoder.")
flac_p = "flac -d -c - 2>/dev/null"
def test_flac(file) =
if test_process("which metaflac") then
channels = list.hd(get_process_lines("metaflac \
--show-channels #{quote(file)} \
2>/dev/null"))
# If the value is not an int, this returns 0 and we are ok :)
int_of_string(channels)
else
# Try to detect using mime test..
mime = get_mime(file)
if string.match(pattern="flac",file) then
# We do not know the number of audio channels
# so setting to -1
(-1)
else
# All tests failed: no audio decodable using flac..
0
end
end
end
add_decoder(name="FLAC",description="Decode files using the flac \
decoder binary.", test=test_flac,flac_p)
else
log(level=3,"flac binary not found: flac decoder disabled.")
end
%endif
if os.type != "Win32" then
if test_process("which metaflac") then
log(level=3,"Found metaflac binary: enabling flac external metadata \
resolver.")
def flac_meta(file)
ret = get_process_lines("metaflac --export-tags-to=- \
#{quote(file)} 2>/dev/null")
ret = list.map(string.split(separator="="),ret)
# Could be made better..
def f(l',l)=
if list.length(l) >= 2 then
list.append([(list.hd(l),list.nth(l,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
add_metadata_resolver("FLAC",flac_meta)
else
log(level=3,"metaflac binary not found: flac metadata resolver disabled.")
end
end
# A list of know extensions and content-type for AAC.
# Values from http://en.wikipedia.org/wiki/Advanced_Audio_Coding
# TODO: can we register a setting for that ??
aac_mimes = ["audio/aac", "audio/aacp", "audio/3gpp", "audio/3gpp2", "audio/mp4",
"audio/MP4A-LATM", "audio/mpeg4-generic", "audio/x-hx-aac-adts"]
aac_filexts = ["m4a", "m4b", "m4p", "m4v",
"m4r", "3gp", "mp4", "aac"]
# Faad is not very selective so
# We are checking only file that
# end with a known extension or mime type
def faad_test(file) =
# Get the file's mime
mime = get_mime(file)
# Test mime
if list.mem(mime,aac_mimes) then
true
else
# Otherwise test file extension
ret = string.extract(pattern='\.(.+)$',file)
if list.length(ret) != 0 then
ext = ret["1"]
list.mem(ext,aac_filexts)
else
false
end
end
end
if os.type != "Win32" then
if test_process("which faad") then
log(level=3,"Found faad binary: enabling external faad decoder and \
metadata resolver.")
faad_p = (fun (f) -> "faad -w #{quote(f)} 2>/dev/null")
def test_faad(file) =
if faad_test(file) then
channels = list.hd(get_process_lines("faad -i #{quote(file)} 2>&1 | \
grep 'ch,'"))
ret = string.extract(pattern=", (\d) ch,",channels)
ret =
if list.length(ret) == 0 then
# If we pass the faad_test, chances are
# high that the file will contain aac audio data..
"-1"
else
ret["1"]
end
int_of_string(default=(-1),ret)
else
0
end
end
%ifdef add_oblivious_decoder
add_oblivious_decoder(name="FAAD",description="Decode files using \
the faad binary.", test=test_faad, faad_p)
%endif
def faad_meta(file) =
if faad_test(file) then
ret = get_process_lines("faad -i \
#{quote(file)} 2>&1")
# Yea, this is tuff programming (again) !
def get_meta(l,s)=
ret = string.extract(pattern="^(\w+):\s(.+)$",s)
if list.length(ret) > 0 then
list.append([(ret["1"],ret["2"])],l)
else
l
end
end
list.fold(get_meta,[],ret)
else
[]
end
end
add_metadata_resolver("FAAD",faad_meta)
else
log(level=3,"faad binary not found: faad decoder disabled.")
end
end

73
pypo/scripts/library/extract-replaygain Executable file
View file

@ -0,0 +1,73 @@
#!/usr/bin/perl -w
use strict ;
my $file = $ARGV[0] || die ;
sub test_mime {
my $file = shift ;
if (`which file`) {
return `file -b --mime-type "$file"`;
}
}
if (($file =~ /\.mp3$/i) || (test_mime($file) =~ /audio\/mpeg/)) {
if (`which mp3gain`) {
my $out = `nice -n 20 mp3gain -q "$file" 2> /dev/null` ;
$out =~ /Recommended "Track" dB change: (.*)$/m || die ;
print "$1 dB\n" ;
} else {
print STDERR "Cannot find mp3gain binary!\n";
}
} elsif (($file =~ /\.ogg$/i) || (test_mime($file) =~ /application\/ogg/)) {
if ((`which vorbisgain`) && (`which ogginfo`)) {
system("nice -n 20 vorbisgain -q -f \"$file\" 2>/dev/null >/dev/null") ;
my $info = `ogginfo "$file"` ;
$info =~ /REPLAYGAIN_TRACK_GAIN=(.*) dB/ || die ;
print "$1 dB\n" ;
} else {
print STDERR "Cannot find vorbisgain or ogginfo!\n";
}
} elsif (($file =~ /\.flac$/i) || (test_mime($file) =~ /audio\/x-flac/)) {
if (`which metaflac`) {
my $info = `metaflac --show-tag=REPLAYGAIN_TRACK_GAIN "$file"` ;
$info =~ /REPLAYGAIN_TRACK_GAIN=(.*) dB/;
if (defined($1)) {
print "$1 dB\n" ;
} else {
system("nice -n 20 metaflac --add-replay-gain \"$file\" \
2>/dev/null >/dev/null") ;
$info = `metaflac --show-tag=REPLAYGAIN_TRACK_GAIN "$file"` ;
$info =~ /REPLAYGAIN_TRACK_GAIN=(.*) dB/ || die "Error in $file" ;
print "$1 dB\n" ;
}
} else {
print STDERR "Cannot find metaflac!\n";
}
} else {
print STDERR "File format not supported...\n";
}

133
pypo/scripts/library/lastfm.liq Normal file
View file

@ -0,0 +1,133 @@
dummy = fun () -> log("Lastfm/audioscrobbler support was not compiled.")
%ifdef input.lastfm
dummy = fun () -> ()
# Utility to compose last.fm URIs.
# @category String
# @param ~user Lastfm user
# @param ~password Lastfm password
# @param ~discovery Allow lastfm suggestions
# @param radio URI, e.g. user/toots5446/playlist, globaltags/rocksteady.
def lastfm.uri(~user="",~password="",~discovery=false,
radio="globaltags/creative-commons")
auth = if user == "" then "" else "#{user}:#{password}@" end
discovery = if discovery == true then "1" else "0" end
"lastfm://#{auth}#{radio}?discovery=#{discovery}"
end
# Submit metadata to libre.fm using the audioscrobbler protocol.
# @category Interaction
# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
def librefm.submit(~user,~password,~source="broadcast",~length=false,m) =
audioscrobbler.submit(user=user,password=password,
source=source,length=length,
host="turtle.libre.fm",port=80,
m)
end
# Submit metadata to lastfm.fm using the audioscrobbler protocol.
# @category Interaction
# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
def lastfm.submit(~user,~password,~source="broadcast",~length=false,m) =
audioscrobbler.submit(user=user,password=password,
source=source,length=length,
host="post.audioscrobbler.com",port=80,
m)
end
# Submit metadata to libre.fm using the audioscrobbler protocol (nowplaying mode).
# @category Interaction
# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
def librefm.nowplaying(~user,~password,~length=false,m) =
audioscrobbler.nowplaying(user=user,password=password,length=length,
host="turtle.libre.fm",port=80,
m)
end
# Submit metadata to lastfm.fm using the audioscrobbler protocol (nowplaying mode).
# @category Interaction
# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
def lastfm.nowplaying(~user,~password,~length=false,m) =
audioscrobbler.nowplaying(user=user,password=password,length=length,
host="post.audioscrobbler.com",port=80,
m)
end
# Submit songs using audioscrobbler, respecting the full protocol:
# First signal song as now playing when starting, and
# then submit song when it ends.
# @category Interaction
# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
# @param ~delay Submit song when there is only this delay left, in seconds.
# @param ~force If remaining time is null, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour.
def audioscrobbler.submit.full(
~user,~password,
~host="post.audioscrobbler.com",~port=80,
~source="broadcast",~length=false,
~delay=10.,~force=false,s) =
f = audioscrobbler.nowplaying(
user=user,password=password,
host=host,port=port,length=length)
s = on_metadata(f,s)
f = fun (rem,m) ->
# Avoid skipped songs
if rem > 0. or force then
audioscrobbler.submit(
user=user,password=password,
host=host,port=port,length=length,
source=source,m)
else
log(label="audioscrobbler.submit.full",
level=4,"Remaining time null: \
will not submit song (song skipped ?)")
end
on_end(delay=delay,f,s)
end
# Submit songs to librefm using audioscrobbler, respecting the full protocol:
# First signal song as now playing when starting, and
# then submit song when it ends.
# @category Interaction
# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
# @param ~delay Submit song when there is only this delay left, in seconds. If remaining time is less than this value, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour.
# @param ~force If remaining time is null, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour.
def librefm.submit.full(
~user,~password,
~source="broadcast",~length=false,
~delay=10.,~force=false,s) =
audioscrobbler.submit.full(
user=user,password=password,
source=source,length=length,
host="turtle.libre.fm",port=80,
delay=delay,force=force,s)
end
# Submit songs to lastfm using audioscrobbler, respecting the full protocol:
# First signal song as now playing when starting, and
# then submit song when it ends.
# @category Interaction
# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
# @param ~delay Submit song when there is only this delay left, in seconds. If remaining time is less than this value, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour.
# @param ~force If remaining time is null, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour.
def lastfm.submit.full(
~user,~password,
~source="broadcast",~length=false,
~delay=10.,~force=false,s) =
audioscrobbler.submit.full(
user=user,password=password,
source=source,length=length,
host="post.audioscrobbler.com",port=80,
delay=delay,force=force,s)
end
%endif
dummy ()

11
pypo/scripts/library/liquidtts Executable file
View file

@ -0,0 +1,11 @@
#!/bin/sh
# This script is called from liquidsoap for generating a file
# for "say:voice/text" URIs.
# Usage: liquidtts text output_file voice
echo $1 | /usr/bin/text2wave -f 44100 > $2.tmp.wav && /usr/bin/sox $2.tmp.wav -t wav -c 2 -r 44100 $2 2> /dev/null > /dev/null
return=$?
/bin/rm $2.tmp.wav
false $2 2> /dev/null > /dev/null
exit $return

4
pypo/scripts/library/pervasives.liq Normal file
View file

@ -0,0 +1,4 @@
%include "utils.liq"
%include "externals.liq"
%include "shoutcast.liq"
%include "lastfm.liq"

49
pypo/scripts/library/shoutcast.liq Normal file
View file

@ -0,0 +1,49 @@
%ifdef output.icecast
# Output to shoutcast.
# @category Source / Output
# @param ~id Output's ID
# @param ~start Start output threads on operator initialization.
# @param ~restart Restart output after a failure. By default, liquidsoap will stop if the output failed.
# @param ~restart_delay Delay, in seconds, before attempting new connection, if restart is enabled.
# @param ~user User for shout source connection. Useful only in special cases, like with per-mountpoint users.
# @param ~icy_reset Reset shoutcast source buffer upon connecting (necessary for NSV).
# @param ~dumpfile Dump stream to file, for debugging purpose. Disabled if empty.
# @param ~fallible Allow the child source to fail, in which case the output will be (temporarily) stopped.
# @param ~on_start Callback executed when outputting starts.
# @param ~on_stop Callback executed when outputting stops.
# @param ~on_connect Callback executed when connection starts.
# @param ~on_disconnect Callback executed when connection stops.
# @param ~icy_metadata Send new metadata using the ICY protocol. One of: "guess", "true", "false"
# @param ~format Format, e.g. "audio/ogg". When empty, the encoder is used to guess.
# @param e Endoding format. For shoutcast, should be mp3 or AAC(+).
# @param s The source to output
def output.shoutcast(
~id="output.shoutcast",~start=true,
~restart=false,~restart_delay=3,
~host="localhost",~port=8000,
~user="source",~password="hackme",
~genre="Misc",~url="http://savonet.sf.net/",
~name="OCaml Radio!",~public=true, ~format="",
~dumpfile="", ~icy_metadata="guess",
~on_connect={()}, ~on_disconnect={()},
~aim="",~icq="",~irc="",~icy_reset=true,
~fallible=false,~on_start={()},~on_stop={()},
e,s) =
icy_reset = if icy_reset then "1" else "0" end
headers = [("icy-aim",aim),("icy-irc",irc),
("icy-icq",icq),("icy-reset",icy_reset)]
output.icecast(
e, format=format,
id=id, headers=headers,
start=start,icy_metadata=icy_metadata,
on_connect=on_connect, on_disconnect=on_disconnect,
restart=restart, restart_delay=restart_delay,
host=host, port=port, user=user, password=password,
genre=genre, url=url, description="UNUSED",
public=public, dumpfile=dumpfile,
name=name, mount="/", protocol="icy",
fallible=fallible,on_start=on_start,on_stop=on_stop,
s)
end
%endif

578
pypo/scripts/library/utils.liq Normal file
View file

@ -0,0 +1,578 @@
# Turn a source into an infaillible source.
# by adding blank when the source is not available.
# @param s the source to turn infaillible
# @category Source / Input
def mksafe(s)
fallback(id="mksafe",track_sensitive=false,[s,blank(id="safe_blank")])
end
# Alias for the <code>l[k]</code> notation.
# @category List
# @param a Key to look for
# @param l List of pairs (key,value)
def list.assoc(a,l)
l[a]
end
# list.mem_assoc(key,l) returns true if l contains a pair
# (key,value)
# @category List
# @param a Key to look for
# @param l List of pairs (key,value)
def list.mem_assoc(a,l)
v = list.assoc(a,l)
# We check for existence, since "" may indicate
# either a binding (a,"") or no binding..
list.mem((a,v),l)
end
# Remove a pair from an associative list
# @category List
# @param a Key of pair to be removed
# @param l List of pairs (key,value)
def list.remove_assoc(a,l)
list.remove((a,list.assoc(a,l)),l)
end
# Rewrite metadata on the fly using a list of (target,rules).
# @category Source / Track Processing
# @param l \
# List of (target,value) rewriting rules.
# @param ~insert_missing \
# Treat track beginnings without metadata as having empty ones. \
# The operational order is: \
# create empty if needed, map and strip if enabled.
# @param ~update \
# Only update metadata. \
# If false, only returned values will be set as metadata.
# @param ~strip \
# Completly remove empty metadata. \
# Operates on both empty values and empty metadata chunk.
def rewrite_metadata(l,~insert_missing=true,
~update=true,~strip=false,
s)
# We don't need to return all values, since
# map_metadata only update returned values.
# So, we simply apply all rewrite rules !
def map(m)
def apply(x)
label = fst(x)
value = snd(x)
(label,value % m)
end
list.map(apply,l)
end
map_metadata(map,insert_missing=insert_missing,
update=update,strip=strip,s)
end
# Add a skip function to a source
# when it does not have one
# by default
# @category Interaction
# @param s The source to attach the command to.
def add_skip_command(s) =
# A command to skip
def skip(_) =
source.skip(s)
"Done!"
end
# Register the command:
server.register(namespace="#{source.id(s)}",
usage="skip",
description="Skip the current song.",
"skip",skip)
end
# Removes all metadata coming from a source
# @category Source / Track Processing
def clear_metadata(s)
def map(m)
[]
end
map_metadata(map,update=false,strip=true,s)
end
output.prefered=output.dummy
%ifdef output.oss
output.prefered=output.oss
%endif
%ifdef output.alsa
output.prefered=output.alsa
%endif
%ifdef output.pulseaudio
output.prefered=output.pulseaudio
%endif
%ifdef output.ao
output.prefered=output.ao
%endif
# Output to local audio card using the first available driver in this list:
# ao, pulseaudio, alsa, oss, dummy
# @category Source / Output
def output.prefered(~id="",s)
output.prefered(id=id,s)
end
in = fun () -> blank()
%ifdef input.oss
in = fun () -> input.oss(id="oss_mic")
%endif
%ifdef input.alsa
in = fun () -> input.alsa(id="alsa_mic")
%endif
%ifdef input.portaudio
in = fun () -> input.portaudio(id="pa_mic")
%endif
# Create a source from the first available input driver in this list:
# portaudio, alsa, oss, blank
# @category Source / Input
def in()
in()
end
# Output a stream using the 'output.prefered' operator. The input source does
# not need to be infallible, blank will just be played during failures.
# @param s the source to output
# @category Source / Output
def out(s)
output.prefered(mksafe(s))
end
# Special track insensitive fallback that
# always skip current song before switching.
# @category Source / Track Processing
# @param ~input The input source
# @param f The fallback source
def fallback.skip(~input,f)
def transition(a,b) =
source.skip(a)
# This eats the last remaining frame from a
sequence([a,b])
end
fallback(track_sensitive=false,transitions=[transition,transition],[input,f])
end
# Compress and normalize, producing a more uniform and "full" sound.
# @category Source / Sound Processing
# @param s The input source.
def nrj(s)
compress(threshold=-15.,ratio=3.,gain=3.,normalize(s))
end
# Multiband-compression.
# @category Source / Sound Processing
# @param s The input source.
def sky(s)
# 3-band crossover
low = filter.iir.eq.low(frequency = 168.)
mh = filter.iir.eq.high(frequency = 100.)
mid = filter.iir.eq.low(frequency = 1800.)
high = filter.iir.eq.high(frequency = 1366.)
# Add back
add(normalize = false,
[ compress(attack = 100., release = 200., threshold = -20.,
ratio = 6., gain = 6.7, knee = 0.3,
low(s)),
compress(attack = 100., release = 200., threshold = -20.,
ratio = 6., gain = 6.7, knee = 0.3,
mid(mh(s))),
compress(attack = 100., release = 200., threshold = -20.,
ratio = 6., gain = 6.7, knee = 0.3,
high(s))
])
end
# Simple crossfade.
# @category Source / Track Processing
# @param ~start_next Duration in seconds of the crossed end of track.
# @param ~fade_in Duration of the fade in for next track
# @param ~fade_out Duration of the fade out for previous track
# @param s The source to use
def crossfade(~id="",~start_next,~fade_in,~fade_out,s)
s = fade.in(duration=fade_in,s)
s = fade.out(duration=fade_out,s)
fader = fun (a,b) -> add(normalize=false,[b,a])
cross(id=id,conservative=true,duration=start_next,fader,s)
end
# Append speech-synthesized tracks reading the metadata.
# @category Source / Track Processing
# @param ~pattern Pattern to use
# @param s The source to use
def say_metadata
p = 'say:$(if $(artist),"It was $(artist)$(if $(title),\", $(title)\").")'
fun (s,~pattern=p) ->
append(s,fun (m) -> request.queue(queue=[request.create(pattern % m)],
interactive=false))
end
# Relay the audio stream of Dolebraï, a libre music netradio running liquidsoap.
# @category Source / Input
def dolebrai ()
input.http(id="dolebrai","http://dolebrai.net:8000/dolebrai.ogg")
end
%ifdef soundtouch
# Increases the pitch, making voices sound like on helium.
# @category Source / Sound Processing
# @param s The input source.
def helium(s)
soundtouch(pitch=1.5,s)
end
%endif
# Return true if process exited with 0 code.
# Command should return quickly.
# @category System
# @param command Command to test
def test_process(command)
lines =
get_process_lines("(" ^ command ^ " >/dev/null 2>&1 && echo 0) || echo 1")
if list.length(lines) == 0 then
false
else
"0" == list.hd(lines)
end
end
# Get the base name of a path.
# Implemented using the corresponding shell command.
# @category System
# @param s Path
def basename(s)
lines = get_process_lines("basename #{quote(s)}")
if list.length(lines) > 0 then
list.hd(lines)
else
# Don't know what to do.. output s
s
end
end
# Get the directory name of a path.
# Implemented using the corresponding shell command.
# @category System
# @param s Path
# @param ~default Value returned in case of error.
def dirname(~default="/nonexistent",s)
lines = get_process_lines("dirname #{quote(s)}")
if list.length(lines) > 0 then
list.hd(lines)
else
default
end
end
# Read some value from standard input (console).
# @category System
# @param ~hide Hide typed characters (for passwords).
def read(~hide=false)
if hide then
system("stty -echo")
end
s = list.hd(get_process_lines("read BLA && echo $BLA"))
if hide then
system("stty echo")
end
print("")
s
end
# Generic mime test. First try to use file.mime if it exist.
# Otherwise try to get the value using the file binary.
# Returns "" (empty string) if no value can be find.
# @category System
# @param file The file to test
def get_mime(file) =
def file_method(file) =
if test_process("which file") then
list.hd(get_process_lines("file -b --mime-type \
#{quote(file)}"))
else
""
end
end
def mime_method(file) =
ret = ""
%ifdef file.mime
ret = file.mime(file)
%endif
ret
end
# First try mime method
ret = mime_method(file)
if ret != "" then
ret
else
# Now try file method
file_method(file)
end
end
# Remove low frequencies often produced by microphones.
# @category Source / Sound Processing
# @param s The input source.
def mic_filter(s)
filter(freq=200.,q=1.,mode="high",s)
end
# Creates a source that fails to produce anything.
# @category Source / Input
def fail()
fallback([])
end
# Creates a source that plays only one track of the input source.
# @category Source / Track Processing
# @param s The input source.
def once(s)
sequence([s,fail()])
end
# Crossfade between tracks, taking the respective volume levels into account in
# the choice of the transition.
# @category Source / Track Processing
# @param ~start_next Crossing duration, if any.
# @param ~fade_in Fade-in duration, if any.
# @param ~fade_out Fade-out duration, if any.
# @param ~width Width of the volume analysis window.
# @param ~conservative Always prepare for a premature end-of-track.
# @param ~default Transition used when no rule applies \
# (default: sequence).
# @param ~high Value, in dB, for loud sound level
# @param ~medium Value, in dB, for medium sound level
# @param ~margin Margin to detect sources that have too different \
# sound level for crossing.
# @param s The input source.
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
# 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
# Custom playlist source written using the script language.
# Will read directory or playlist, play all files and stop
# @category Source / Input
# @param ~random Randomize playlist content
# @param ~on_done Function to execute when the playlist is finished
# @param uri Playlist URI
def playlist.once(~random=false,~on_done={()},uri)
x = ref 0
def playlist.custom(files)
length = list.length(files)
if length == 0 then
log("Empty playlist..")
fail ()
else
files =
if random then
list.sort(fun (x,y) -> int_of_float(random.float()), files)
else
files
end
def next () =
state = !x
file =
if state < length then
x := state + 1
list.nth(files,state)
else
# Playlist finished
on_done ()
""
end
request.create(file)
end
request.dynamic(next)
end
end
if test_process("test -d #{quote(uri)}") then
files = get_process_lines("find #{quote(uri)} -type f | sort")
playlist.custom(files)
else
playlist = request.create.raw(uri)
result =
if request.resolve(playlist) then
playlist = request.filename(playlist)
files = playlist.parse(playlist)
files = list.map(snd,files)
playlist.custom(files)
else
log("Couldn't read playlist: request resolution failed.")
fail ()
end
request.destroy(playlist)
result
end
end
# Mixes two streams, with faded transitions between the state when only the
# normal stream is available and when the special stream gets added on top of
# it.
# @category Source / Track Processing
# @param ~delay Delay before starting the special source.
# @param ~p Portion of amplitude of the normal source in the mix.
# @param ~normal The normal source, which could be called the carrier too.
# @param ~special The special source.
def smooth_add(~delay=0.5,~p=0.2,~normal,~special)
d = delay
fade.final = fade.final(duration=d*2.)
fade.initial = fade.initial(duration=d*2.)
q = 1. - p
c = amplify
fallback(track_sensitive=false,
[special,normal],
transitions=[
fun(normal,special)->
add(normalize=false,
[c(p,normal),
c(q,fade.final(type="sin",normal)),
sequence([blank(duration=d),c(q,special)])]),
fun(special,normal)->
add(normalize=false,
[c(p,normal),
c(q,fade.initial(type="sin",normal))])
])
end
# Restrict a source to play only when a predicate is true.
# @category Source / Track Processing
# @param pred The predicate, typically a time interval such as \
# <code>{10h-10h30}</code>.
def at(pred,s)
switch([(pred,s)])
end
# Execute a given action when a predicate is true.
# This will be run in background.
# @category System
# @param ~freq Frequency for checking the predicate, in seconds.
# @param ~pred Predicate indicating when to execute the function, \
# typically a time interval such as <code>{10h-10h30}</code>.
# @param f Function to execute when the predicate is true.
def exec_at(~freq=1.,~pred,f)
def check()
if pred() then
f()
end
freq
end
add_timeout(freq,check)
end
# Register the replaygain protocol
def replaygain_protocol(arg,delay)
# The extraction program
extract_replaygain = "#{configure.libdir}/extract-replaygain"
x = get_process_lines("#{extract_replaygain} #{quote(arg)}")
if list.hd(x) != "" then
["annotate:replay_gain=\"#{list.hd(x)}\":#{arg}"]
else
[arg]
end
end
add_protocol("replay_gain", replaygain_protocol)
# Enable replay gain metadata resolver. This resolver will
# process any file decoded by liquidsoap and add a @replay_gain@
# metadata when this value could be computed. For a finer-grained
# replay gain processing, use the @replay_gain@ protocol.
# @category Liquidsoap
# @param ~extract_replaygain The extraction program
def enable_replaygain_metadata(
~extract_replaygain="#{configure.libdir}/extract-replaygain")
def replaygain_metadata(file)
x = get_process_lines("#{extract_replaygain} \
#{quote(file)}")
if list.hd(x) != "" then
[("replay_gain",list.hd(x))]
else
[]
end
end
add_metadata_resolver("replay_gain", replaygain_metadata)
end
# Create a log of clock times for all the clocks initially present.
# The log is in simple format, which you can notably directly use with gnuplot.
# @category Liquidsoap
# @param ~interval Polling interval.
def log_clocks(~interval=1.,logfile)
# Get the current clocks
clocks = list.map(fst,get_clock_status())
# Column headers
system("echo \# #{string.concat(separator=' ',clocks)} > #{logfile}")
def report()
status = get_clock_status()
status = list.map(fun (x) -> (fst(x),string_of(snd(x))), status)
status = list.map(fun (c) -> status[c], clocks)
system("echo #{string.concat(separator=' ',status)} >> #{logfile}")
interval
end
add_timeout(interval,report)
end

18
pypo/scripts/log_run.sh Executable file
View file

@ -0,0 +1,18 @@
#!/bin/sh
DATE=$(date '+%Y-%m-%d')
CI_LOG=/var/log/obp/ci/log-$DATE.php
clear
echo
echo "##############################"
echo "# STARTING PYPO MULTI-LOG #"
echo "##############################"
sleep 1
clear
# split
multitail -s 2 -cS pyml /var/log/obp/pypo/debug.log \
-cS pyml /var/log/obp/pypo/error.log \
-l "tail -f -n 50 $CI_LOG | grep API" \
/var/log/obp/ls/ls_script.log

49
pypo/scripts/ls_config.liq Normal file
View file

@ -0,0 +1,49 @@
###########################################
# liquidsoap config file #
###########################################
# author Jonas Ohrstrom <jonas@digris.ch>
# this file is specific to the obp
# installation. eg it assumes that there are
# two instances of LS running
# the "scheduler" & the "fallback" instance
###########################################
# general settings #
###########################################
log_file = "/var/log/obp/ls/<script>.log"
log_level = 3
# archive directory
archive_dir = "/storage/pypo/archive/"
# list pointing to the current couchcaster mountpoint
couchcaster_list = "http://vdeb.openbroadcast.ch/mod/ml/api/pypo/current_couchcaster"
###########################################
# stream settings #
###########################################
icecast_host = "172.16.16.128"
icecast_port = 8000
icecast_pass = "hackme"
# mountpoints
mount_scheduler = "pypo_scheduler.mp3"
mount_fallback = "pypo_fallback.mp3"
mount_final = "pypo_final.mp3"
# mount intra is used for scheduler >>> fallback stream
mount_intra = "pypo_intra"
# intra-LS streaming (no icecast here)
intra_host = "172.16.16.128"
intra_port = 9000
intra_pass = "hackme"

46
pypo/scripts/ls_config.liq.dist Normal file
View file

@ -0,0 +1,46 @@
###########################################
# liquidsoap config file #
###########################################
# this file is specific to the obp
# installation. eg it assumes that there are
# two instances of LS running
# the "scheduler" & the "fallback" instance
###########################################
# general settings #
###########################################
log_file = "/var/log/obp/ls/<script>.log"
log_level = 5
# archive directory
archive_dir = "/storage/pypo/archive/"
# list pointing to the current couchcaster mountpoint
couchcaster_list = "http://stage.openbroadcast.ch/mod/ml/api/pypo/current_couchcaster"
###########################################
# stream settings #
###########################################
icecast_host = "stream.domain.com"
icecast_port = 8000
icecast_pass = "hackme"
# mountpoints
mount_scheduler = "pypo_scheduler.mp3"
mount_fallback = "pypo_fallback.mp3"
mount_final = "pypo_final.mp3"
# mount intra is used for scheduler >>> fallback stream
mount_intra = "pypo_intra"
# intra-LS streaming (no icecast here)
intra_host = "pypo-fallback.my-playout-server.xyz.net"
intra_port = 9000
intra_pass = "hackmetoo"

36
pypo/scripts/ls_cue.liq Normal file
View file

@ -0,0 +1,36 @@
# Register the cut protocol
def cue_protocol(arg,delay)
# The extraction program
# cut_file = "#{configure.libdir}/cut-file.py"
cue_script = "./cue_file.py"
# Parse args
ret = string.extract(pattern="cue_in=(\d+)",arg)
start =
if list.length(ret) == 0 then
"0"
else
ret["1"]
end
ret = string.extract(pattern="cue_out=(\d+)",arg)
stop =
if list.length(ret) == 0 then
"0"
else
ret["1"]
end
ret = string.extract(pattern=":(.*)$",arg)
uri =
if list.length(ret) == 0 then
""
else
ret["1"]
end
x = get_process_lines("#{cue_script} #{quote(uri)} #{start} #{stop}")
if list.hd(x) != "" then
([list.hd(x)],[])
else
([uri],[])
end
end
add_post_processor("cue_file", temporary=true, cue_protocol)

7
pypo/scripts/ls_run.sh Executable file
View file

@ -0,0 +1,7 @@
#!/bin/sh
# export home dir
export HOME=/home/liquidsoap/
# start liquidsoap with corresponding user & scrupt
sudo -u liquidsoap /usr/local/bin/liquidsoap ls_script.liq

154
pypo/scripts/ls_script.liq Normal file
View file

@ -0,0 +1,154 @@
######################################
# main liquidsoap development script #
######################################
# author Jonas Ohrstrom <jonas@digris.ch>
########################################
# include configuration #
########################################
%include "ls_config.liq"
%include "library.liq"
%include "include_dynamic_vars.liq"
%include "include_notify.liq"
silence_threshold = -50.
silence_time = 3.
# log
set("log.file.path",log_file)
set("log.stdout", true)
set("log.level",log_level)
# telnet server
set("server.telnet", true)
######################################
# some functions needed #
######################################
def fcross(a,b) =
add(normalize=false,[b,a])
end
######################################
# live recording functions
######################################
def live_start() =
log("got live source")
ignore(execute("archives.start"))
end
def live_stop() =
log("live source has gone")
ignore(execute("archives.stop"))
end
#######################################################################
# File locations / sources
#######################################################################
silence = single("/storage/pypo/files/basic/silence.mp3")
jingles_cc = playlist("/storage/pypo/files/jingles/jcc")
fallback_couchcaster = playlist("/storage/pypo/files/fallback_couchcaster")
fallback_couchcaster = audio_to_stereo(fallback_couchcaster)
# default
default = silence
special = request.queue(id="special")
#######################################################################
# Includeing two A/B Queues, daypart & scheduler
# this will give us the sources 'daypart' & 'scheduler'
#######################################################################
%include "include_daypart.liq"
%include "include_scheduler.liq"
source = fallback(track_sensitive=false,transitions=[dp_to_scheduler],[strip_blank(threshold=silence_threshold,length=silence_time,scheduler),daypart])
%include "include_live_in.liq"
live = fallback(track_sensitive=false,[strip_blank(threshold=silence_threshold,length=silence_time,live),fallback_couchcaster])
live = switch(track_sensitive=false, [({!live_active},live)])
source = fallback(track_sensitive=false,transitions=[to_live_s, to_scheduler_s],[live, source])
# handle the annotate fades
faded = fade.in(type="log", fade.out(type="log", source))
# add up with a crossfade function (defined above)
source = cross(fcross,faded)
# track start detection (for notifications)
source = on_metadata(notify, source)
#source = on_track(notify, source)
# special to mix with final source
source = smooth_add(normal=source,special=special)
#####################################
# Stream Output
#####################################
# finally the output | mp3
clock(id="clock_icecast",
output.icecast(%mp3,
host = icecast_host, port = icecast_port,
password = icecast_pass, mount = mount_scheduler,
fallible = true,
restart = true,
restart_delay = 5,
buffer(source)))
#output.dummy(live_in)

8
pypo/scripts/notify.sh Executable file
View file

@ -0,0 +1,8 @@
#!/bin/sh
############################################
# just a wrapper to call the notifyer #
# needed here to keep dirs/configs clean #
# and maybe to set user-rights #
############################################
cd ../
./pypo_notify.py $1 $2 $3 $4 $5 $6 $7 $8 &

15
pypo/scripts/pypo_log.sh Executable file
View file

@ -0,0 +1,15 @@
#!/bin/sh
clear
echo
echo "##############################"
echo "# STARTING PYPO MULTI-LOG #"
echo "##############################"
sleep 1
clear
# split
multitail -s 2 /var/log/obp/pypo/debug.log \
/var/svc.d/pypo_push/log/main/current \
/var/svc.d/pypo_fetch/log/main/current \
/var/svc.d/pypo_ls/log/main/current

BIN
pypo/scripts/silence.mp3 Normal file
View file

Binary file not shown.

5
pypo/util/__init__.py Normal file
View file

@ -0,0 +1,5 @@
# -*- coding: utf-8 -*-
from json import *
from status import *
from cue_file import *

79
pypo/util/cue_file.py Executable file
View file

@ -0,0 +1,79 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import shutil
import random
import string
import time
from datetime import timedelta
import os
import logging
from mutagen.mp3 import MP3
class CueFile():
def __init__(self):
logger = logging.getLogger("cue_file")
logger.debug("init")
def cue(self, src, dst, cue_in, cue_out):
logger = logging.getLogger("cue_file.cue")
logger.debug("cue file: %s %s %s %s", src, dst, cue_in, cue_out)
# mutagen
audio = MP3(src)
dur = round(audio.info.length, 3)
logger.debug("duration by mutagen: %s", dur)
cue_out = round(float(dur) - cue_out, 3)
str_cue_in = str(timedelta(seconds=cue_in)).replace(".", "+") # hh:mm:ss+mss, eg 00:00:20+000
str_cue_out = str(timedelta(seconds=cue_out)).replace(".", "+") #
"""
now a bit a hackish part, don't know how to do this better...
need to cut the digits after the "+"
"""
ts = str_cue_in.split("+")
try:
if len(ts[1]) == 6:
ts[1] = ts[1][0:3]
str_cue_in = "%s+%s" % (ts[0], ts[1])
except Exception, e:
pass
ts = str_cue_out.split("+")
try:
if len(ts[1]) == 6:
ts[1] = ts[1][0:3]
str_cue_out = "%s+%s" % (ts[0], ts[1])
except Exception, e:
pass
#sys.stderr.write(str(timedelta(seconds=cue_in)).replace(".", "+") + '\n\n')
logger.debug("in: %s", str_cue_in)
logger.debug("out: %s", str(str_cue_out) )
# command = 'mp3cut -o %s -t %s-%s %s' % (dst, str_cue_in, str_cue_out, src);
# logger.info("command: %s", command)
# os.system(command + ' >/dev/null')
#
# command = 'mp3val -f %s' % (dst);
# logger.info("command: %s", command)
# os.system(command + ' >/dev/null')
command = 'mp3cut -o %s -t %s-%s %s' % (dst + '.tmp.mp3', str_cue_in, str_cue_out, src);
logger.info("command: %s", command)
os.system(command + ' >/dev/null')
command = 'lame -b 32 %s %s' % (dst + '.tmp.mp3', dst);
logger.info("command: %s", command)
os.system(command + ' >/dev/null')
return dst

310
pypo/util/json.py Normal file
View file

@ -0,0 +1,310 @@
import string
import types
## json.py implements a JSON (http://json.org) reader and writer.
## Copyright (C) 2005 Patrick D. Logan
## Contact mailto:patrickdlogan@stardecisions.com
##
## This library is free software; you can redistribute it and/or
## modify it under the terms of the GNU Lesser General Public
## License as published by the Free Software Foundation; either
## version 2.1 of the License, or (at your option) any later version.
##
## This library 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
## Lesser General Public License for more details.
##
## You should have received a copy of the GNU Lesser General Public
## License along with this library; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
class _StringGenerator(object):
def __init__(self, string):
self.string = string
self.index = -1
def peek(self):
i = self.index + 1
if i < len(self.string):
return self.string[i]
else:
return None
def next(self):
self.index += 1
if self.index < len(self.string):
return self.string[self.index]
else:
raise StopIteration
def all(self):
return self.string
class WriteException(Exception):
pass
class ReadException(Exception):
pass
class JsonReader(object):
hex_digits = {'A': 10,'B': 11,'C': 12,'D': 13,'E': 14,'F':15}
escapes = {'t':'\t','n':'\n','f':'\f','r':'\r','b':'\b'}
def read(self, s):
self._generator = _StringGenerator(s)
result = self._read()
return result
def _read(self):
self._eatWhitespace()
peek = self._peek()
if peek is None:
raise ReadException, "Nothing to read: '%s'" % self._generator.all()
if peek == '{':
return self._readObject()
elif peek == '[':
return self._readArray()
elif peek == '"':
return self._readString()
elif peek == '-' or peek.isdigit():
return self._readNumber()
elif peek == 't':
return self._readTrue()
elif peek == 'f':
return self._readFalse()
elif peek == 'n':
return self._readNull()
elif peek == '/':
self._readComment()
return self._read()
else:
raise ReadException, "Input is not valid JSON: '%s'" % self._generator.all()
def _readTrue(self):
self._assertNext('t', "true")
self._assertNext('r', "true")
self._assertNext('u', "true")
self._assertNext('e', "true")
return True
def _readFalse(self):
self._assertNext('f', "false")
self._assertNext('a', "false")
self._assertNext('l', "false")
self._assertNext('s', "false")
self._assertNext('e', "false")
return False
def _readNull(self):
self._assertNext('n', "null")
self._assertNext('u', "null")
self._assertNext('l', "null")
self._assertNext('l', "null")
return None
def _assertNext(self, ch, target):
if self._next() != ch:
raise ReadException, "Trying to read %s: '%s'" % (target, self._generator.all())
def _readNumber(self):
isfloat = False
result = self._next()
peek = self._peek()
while peek is not None and (peek.isdigit() or peek == "."):
isfloat = isfloat or peek == "."
result = result + self._next()
peek = self._peek()
try:
if isfloat:
return float(result)
else:
return int(result)
except ValueError:
raise ReadException, "Not a valid JSON number: '%s'" % result
def _readString(self):
result = ""
assert self._next() == '"'
try:
while self._peek() != '"':
ch = self._next()
if ch == "\\":
ch = self._next()
if ch in 'brnft':
ch = self.escapes[ch]
elif ch == "u":
ch4096 = self._next()
ch256 = self._next()
ch16 = self._next()
ch1 = self._next()
n = 4096 * self._hexDigitToInt(ch4096)
n += 256 * self._hexDigitToInt(ch256)
n += 16 * self._hexDigitToInt(ch16)
n += self._hexDigitToInt(ch1)
ch = unichr(n)
elif ch not in '"/\\':
raise ReadException, "Not a valid escaped JSON character: '%s' in %s" % (ch, self._generator.all())
result = result + ch
except StopIteration:
raise ReadException, "Not a valid JSON string: '%s'" % self._generator.all()
assert self._next() == '"'
return result
def _hexDigitToInt(self, ch):
try:
result = self.hex_digits[ch.upper()]
except KeyError:
try:
result = int(ch)
except ValueError:
raise ReadException, "The character %s is not a hex digit." % ch
return result
def _readComment(self):
assert self._next() == "/"
second = self._next()
if second == "/":
self._readDoubleSolidusComment()
elif second == '*':
self._readCStyleComment()
else:
raise ReadException, "Not a valid JSON comment: %s" % self._generator.all()
def _readCStyleComment(self):
try:
done = False
while not done:
ch = self._next()
done = (ch == "*" and self._peek() == "/")
if not done and ch == "/" and self._peek() == "*":
raise ReadException, "Not a valid JSON comment: %s, '/*' cannot be embedded in the comment." % self._generator.all()
self._next()
except StopIteration:
raise ReadException, "Not a valid JSON comment: %s, expected */" % self._generator.all()
def _readDoubleSolidusComment(self):
try:
ch = self._next()
while ch != "\r" and ch != "\n":
ch = self._next()
except StopIteration:
pass
def _readArray(self):
result = []
assert self._next() == '['
done = self._peek() == ']'
while not done:
item = self._read()
result.append(item)
self._eatWhitespace()
done = self._peek() == ']'
if not done:
ch = self._next()
if ch != ",":
raise ReadException, "Not a valid JSON array: '%s' due to: '%s'" % (self._generator.all(), ch)
assert ']' == self._next()
return result
def _readObject(self):
result = {}
assert self._next() == '{'
done = self._peek() == '}'
while not done:
key = self._read()
if type(key) is not types.StringType:
raise ReadException, "Not a valid JSON object key (should be a string): %s" % key
self._eatWhitespace()
ch = self._next()
if ch != ":":
raise ReadException, "Not a valid JSON object: '%s' due to: '%s'" % (self._generator.all(), ch)
self._eatWhitespace()
val = self._read()
result[key] = val
self._eatWhitespace()
done = self._peek() == '}'
if not done:
ch = self._next()
if ch != ",":
raise ReadException, "Not a valid JSON array: '%s' due to: '%s'" % (self._generator.all(), ch)
assert self._next() == "}"
return result
def _eatWhitespace(self):
p = self._peek()
while p is not None and p in string.whitespace or p == '/':
if p == '/':
self._readComment()
else:
self._next()
p = self._peek()
def _peek(self):
return self._generator.peek()
def _next(self):
return self._generator.next()
class JsonWriter(object):
def _append(self, s):
self._results.append(s)
def write(self, obj, escaped_forward_slash=False):
self._escaped_forward_slash = escaped_forward_slash
self._results = []
self._write(obj)
return "".join(self._results)
def _write(self, obj):
ty = type(obj)
if ty is types.DictType:
n = len(obj)
self._append("{")
for k, v in obj.items():
self._write(k)
self._append(":")
self._write(v)
n = n - 1
if n > 0:
self._append(",")
self._append("}")
elif ty is types.ListType or ty is types.TupleType:
n = len(obj)
self._append("[")
for item in obj:
self._write(item)
n = n - 1
if n > 0:
self._append(",")
self._append("]")
elif ty is types.StringType or ty is types.UnicodeType:
self._append('"')
obj = obj.replace('\\', r'\\')
if self._escaped_forward_slash:
obj = obj.replace('/', r'\/')
obj = obj.replace('"', r'\"')
obj = obj.replace('\b', r'\b')
obj = obj.replace('\f', r'\f')
obj = obj.replace('\n', r'\n')
obj = obj.replace('\r', r'\r')
obj = obj.replace('\t', r'\t')
self._append(obj)
self._append('"')
elif ty is types.IntType or ty is types.LongType:
self._append(str(obj))
elif ty is types.FloatType:
self._append("%f" % obj)
elif obj is True:
self._append("true")
elif obj is False:
self._append("false")
elif obj is None:
self._append("null")
else:
raise WriteException, "Cannot write in JSON: %s" % repr(obj)
def write(obj, escaped_forward_slash=False):
return JsonWriter().write(obj, escaped_forward_slash)
def read(s):
return JsonReader().read(s)

59
pypo/util/status.py Normal file
View file

@ -0,0 +1,59 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import time
import urllib
import logging
import telnetlib
from util import json
import os
ALLOWED_EXTS = ('mp3')
class Callable:
def __init__(self, anycallable):
self.__call__ = anycallable
class Status:
def __init__(self, status_url):
self.status_url = status_url
def get_obp_version(self):
logger = logging.getLogger("status.get_obp_version")
# lookup OBP version
try:
response = urllib.urlopen(self.status_url)
response_json = json.read(response.read())
obp_version = int(response_json['version'])
logger.debug("OBP Version %s detected", obp_version)
except Exception, e:
print e
obp_version = 0
logger.error("Unable to detect OBP Version - %s", e)
return obp_version
def check_ls(self, ls_host, ls_port):
logger = logging.getLogger("status.get_ls_version")
# lookup OBP version
try:
tn = telnetlib.Telnet(ls_host, ls_port)
tn.write("\n")
tn.write("version\n")
tn.write("exit\n")
print tn.read_all()
logger.info("liquidsoap connection ok")
return 1
except Exception, e:
obp_version = 0
logger.error("Unable to connect to liquidsoap")
return 0