def operation_to_function(operation):
if not operation:
raise roundexception.RoundException("Operation is required")
operations = {
"request_stream": server.request_stream,
"heartbeat": server.heartbeat,
"current_version": server.current_version,
"log_event": server.log_event,
"create_envelope": server.create_envelope,
"add_asset_to_envelope": server.add_asset_to_envelope,
"get_config": server.get_config,
"get_tags": server.get_tags_for_project,
"modify_stream": server.modify_stream,
"get_current_streaming_asset": server.get_current_streaming_asset,
"get_asset_info": server.get_asset_info,
"get_available_assets": server.get_available_assets,
"play_asset_in_stream": server.play_asset_in_stream,
"vote_asset": server.vote_asset,
"skip_ahead": server.skip_ahead,
}
key = string.lower(operation)
if operations.has_key(key):
return operations[key]
else:
raise roundexception.RoundException("Invalid operation, " + operation)
def skip_ahead(request):
form = request.GET
db.log_event("skip_ahead", int(form['session_id']), form)
if not form.has_key('session_id'):
raise roundexception.RoundException(
"a session_id is required for this operation")
if check_for_single_audiotrack(form.get('session_id')) != True:
raise roundexception.RoundException(
"this operation is only valid for projects with 1 audiotrack")
rounddbus.emit_stream_signal(int(form['session_id']), "skip_ahead", "")
return {"success": True}
def log_event(request):
form = request.GET
if not form.has_key('session_id'):
raise roundexception.RoundException(
"a session_id is required for this operation")
if not form.has_key('event_type'):
raise roundexception.RoundException(
"an event_type is required for this operation")
db.log_event(form.get('event_type'), form.get('session_id'), form)
return {"success": True}
def initialize_config(filename):
global config
if os.access(filename, os.F_OK):
config = False
config = read_configfile(filename)
else:
raise roundexception.RoundException("Config file not found")
def log_event(event_type, session_id, form):
s = Session.objects.get(id=session_id)
if s == None:
raise roundexception.RoundException("failed to access session " +
str(session_id))
client_time = None
latitude = None
longitude = None
tags = None
data = None
if form != None:
if form.has_key("client_time"):
client_time = form["client_time"]
if form.has_key("latitude"):
latitude = form["latitude"]
if form.has_key("longitude"):
longitude = form["longitude"]
if form.has_key("tags"):
tags = form["tags"]
if form.has_key("data"):
data = form["data"]
e = Event(session=s,
event_type=event_type,
server_time=datetime.datetime.now(),
client_time=client_time,
latitude=latitude,
longitude=longitude,
tags=tags,
data=data)
e.save()
return True
def discovered(d, is_media):
if is_media:
recording.audiolength = d.audiolength
recording.save()
#db.update_audiolength(filename, d.audiolength)
main_loop.quit()
else:
roundexception.RoundException("Recorded file is corrupt:" +
filename)
def get_asset_info(request):
form = request.GET
if not form.has_key('asset_id'):
raise roundexception.RoundException(
"an asset_id is required for this operation")
if check_for_single_audiotrack(form.get('session_id')) != True:
raise roundexception.RoundException(
"this operation is only valid for projects with 1 audiotrack")
else:
a = db.get_asset(form.get('asset_id'))
if a:
return {
"asset_id": a.id,
"created": a.created.isoformat(),
"duraton_in_ms": a.audiolength / 1000000
}
else:
return {"user_error_message": "asset not found"}
def get_current_streaming_asset(request):
form = request.GET
if not form.has_key('session_id'):
raise roundexception.RoundException(
"a session_id is required for this operation")
if check_for_single_audiotrack(form.get('session_id')) != True:
raise roundexception.RoundException(
"this operation is only valid for projects with 1 audiotrack")
else:
l = db.get_current_streaming_asset(form.get('session_id'))
if l:
return {
"asset_id": l.asset.id,
"start_time": l.starttime.isoformat(),
"duration_in_stream": l.duration / 1000000,
"current_server_time": datetime.datetime.now().isoformat()
}
else:
return {"user_error_message": "no asset found"}
def get_parameter_from_request(request, name, required):
ret = None
if request.POST.has_key(name):
ret = request.POST.get(name)
elif request.GET.has_key(name):
ret = request.GET.get(name)
else:
if required:
raise roundexception.RoundException(
name + " is required for this operation")
return ret
def play_asset_in_stream(request):
form = request.GET
# add skipped asset_id to form in order to track which asset is played
#assetid = form[asset_id]
#form[data] = form["asset_id"]
request = form_to_request(form)
arg_hack = json.dumps(request)
db.log_event("play_asset_in_stream", int(form['session_id']), form)
if not form.has_key('session_id'):
raise roundexception.RoundException(
"a session_id is required for this operation")
if check_for_single_audiotrack(form.get('session_id')) != True:
raise roundexception.RoundException(
"this operation is only valid for projects with 1 audiotrack")
if not form.has_key('asset_id'):
raise roundexception.RoundException(
"an asset_id is required for this operation")
rounddbus.emit_stream_signal(int(form['session_id']), "play_asset",
arg_hack)
return {"success": True}
def get_tags_for_project(request):
form = request.GET
p = None
s = None
if not form.has_key('project_id') and not form.has_key('session_id'):
raise roundexception.RoundException(
"either a project_id or session_id is required for this operation")
if form.has_key('project_id'):
p = models.Project.objects.get(id=form.get('project_id'))
if form.has_key('session_id'):
s = models.Session.objects.get(id=form.get('session_id'))
return db.get_config_tag_json(p, s)
def create_envelope(request):
form = request.GET
if not form.has_key('session_id'):
raise roundexception.RoundException(
"a session_id is required for this operation")
s = models.Session.objects.get(id=form.get('session_id'))
#todo - tags
env = models.Envelope(session=s)
env.save()
return {"envelope_id": env.id}
def wait_for_stream(sessionid, audio_format):
logging.debug("waiting " + str(sessionid) + audio_format)
admin = icecast2.Admin(
settings.config["icecast_host"] + ":" +
str(settings.config["icecast_port"]),
settings.config["icecast_username"],
settings.config["icecast_password"])
retries_left = 1000
while not admin.stream_exists(icecast_mount_point(sessionid,
audio_format)):
if retries_left > 0:
retries_left -= 1
else:
raise roundexception.RoundException("Stream timedout on creation")
time.sleep(0.1)
def convert_uploaded_file(filename):
(filename_prefix, filename_extension) = os.path.splitext(filename)
upload_dir = get_upload_directory(filename_extension)
filepath = os.path.join(upload_dir, filename)
if not os.path.exists(filepath):
raise roundexception.RoundException("Uploaded file not found: " +
filepath)
elif filename_extension == '.caf':
convert_audio_file(upload_dir, filename_prefix, filename_extension,
'wav')
convert_audio_file(settings.config["audio_dir"], filename_prefix,
'.wav', 'mp3')
return filename_prefix + '.wav'
else:
convert_audio_file(upload_dir, filename_prefix, filename_extension,
'wav')
convert_audio_file(upload_dir, filename_prefix, filename_extension,
'mp3')
return filename_prefix + '.wav'
def modify_stream(request):
success = False
msg = ""
form = request.GET
request = form_to_request(form)
arg_hack = json.dumps(request)
db.log_event("modify_stream", int(form['session_id']), form)
if form.has_key('session_id'):
session = models.Session.objects.select_related('project').get(
id=form['session_id'])
project = session.project
if form.has_key('language'):
try:
logging.debug("modify_stream: language: " + form['language'])
l = models.Language.objects.filter(
language_code=form['language'])[0]
session.language = l
session.save()
except:
raise roundexception.RoundException("language not supported")
audio_format = project.audio_format.upper()
if stream_exists(int(form['session_id']), audio_format):
rounddbus.emit_stream_signal(int(form['session_id']),
"modify_stream", arg_hack)
success = True
else:
msg = "no stream available for session: " + form['session_id']
else:
msg = "a session_id is required for this operation"
if success:
return {"success": success}
else:
return {
"success": success,
}
def vote_asset(request):
form = request.GET
db.log_event("vote_asset", int(form['session_id']), form)
if not form.has_key('session_id'):
raise roundexception.RoundException(
"a session_id is required for this operation")
if not form.has_key('asset_id'):
raise roundexception.RoundException(
"an asset_id is required for this operation")
if not form.has_key('vote_type'):
raise roundexception.RoundException(
"a vote_type is required for this operation")
if check_for_single_audiotrack(form.get('session_id')) != True:
raise roundexception.RoundException(
"this operation is only valid for projects with 1 audiotrack")
try:
session = models.Session.objects.get(id=int(form.get('session_id')))
except:
raise roundexception.RoundException("Session not found.")
try:
asset = models.Asset.objects.get(id=int(form.get('asset_id')))
except:
raise roundexception.RoundException("asset not found.")
if not form.has_key('value'):
v = models.Vote(asset=asset,
session=session,
type=form.get('vote_type'))
else:
v = models.Vote(asset=asset,
session=session,
value=int(form.get('value')),
type=form.get('vote_type'))
v.save()
return {"success": True}
def get_config(request):
form = request.GET
try:
hostname_without_port = str(
settings.config["external_host_name_without_port"])
except KeyError:
raise roundexception.RoundException(
"Roundware configuration file is missing 'external_host_name_without_port' key. "
)
#check params
if not form.has_key('project_id'):
raise roundexception.RoundException(
"a project_id is required for this operation")
project = models.Project.objects.get(id=form.get('project_id'))
speakers = models.Speaker.objects.filter(
project=form.get('project_id')).values()
audiotracks = models.Audiotrack.objects.filter(
project=form.get('project_id')).values()
if not form.has_key('device_id') or (form.has_key('device_id')
and form['device_id'] == ""):
device_id = str(uuid.uuid4())
else:
device_id = form.get('device_id')
l = models.Language.objects.filter(language_code='en')[0]
if form.has_key('language') or (form.has_key('language')
and form['language'] == ""):
try:
l = models.Language.objects.filter(
language_code=form.get('language'))[0]
except:
pass
s = models.Session(device_id=device_id,
starttime=datetime.datetime.now(),
project=project,
language=l)
if form.has_key('client_type'):
s.client_type = form.get('client_type')
if form.has_key('client_system'):
s.client_system = form.get('client_system')
sharing_url = str.format(
"http://{0}/roundware/?operation=view_envelope&envelopeid=[id]",
hostname_without_port)
sharing_message = "none set"
out_of_range_message = "none set"
legal_agreement = "none set"
demo_stream_message = "none set"
try:
sharing_message = project.sharing_message_loc.filter(
language=l)[0].localized_string
except:
pass
try:
out_of_range_message = project.out_of_range_message_loc.filter(
language=l)[0].localized_string
except:
pass
try:
legal_agreement = project.legal_agreement_loc.filter(
language=l)[0].localized_string
except:
pass
try:
demo_stream_message = project.demo_stream_message_loc.filter(
language=l)[0].localized_string
except:
pass
cpu_idle = psutil.cpu_times_percent().idle
s.demo_stream_enabled = project.demo_stream_enabled or cpu_idle < float(
settings.config["demo_stream_cpu_limit"])
s.save()
session_id = s.id
response = [
{
"device": {
"device_id": device_id
}
},
{
"session": {
"session_id": session_id
}
},
{
"project": {
"project_id": project.id,
"project_name": project.name,
"audio_format": project.audio_format,
"max_recording_length": project.max_recording_length,
"recording_radius": project.recording_radius,
"sharing_message": sharing_message,
"out_of_range_message": out_of_range_message,
"sharing_url": project.sharing_url,
"listen_questions_dynamic": project.listen_questions_dynamic,
"speak_questions_dynamic": project.speak_questions_dynamic,
"listen_enabled": project.listen_enabled,
"geo_listen_enabled": project.geo_listen_enabled,
"speak_enabled": project.speak_enabled,
"geo_speak_enabled": project.geo_speak_enabled,
"reset_tag_defaults_on_startup":
project.reset_tag_defaults_on_startup,
"legal_agreement": legal_agreement,
"files_url": project.files_url,
"files_version": project.files_version,
"audio_stream_bitrate": project.audio_stream_bitrate,
# TODO: following attribute 'demo_stream_enabled' has be moved to the 'session' object
"demo_stream_enabled": s.demo_stream_enabled,
"demo_stream_url": project.demo_stream_url,
"demo_stream_message": demo_stream_message,
}
},
{
"server": {
"version": "2.0"
}
},
{
"speakers": [dict(d) for d in speakers]
},
{
"audiotracks": [dict(d) for d in audiotracks]
}
]
db.log_event('start_session', session_id, None)
return response
def read_configfile(filename):
configspec = StringIO.StringIO(configstring)
tmpconfig = configobj.ConfigObj(filename, configspec=configspec)
if not tmpconfig.validate(validate.Validator(), copy=True):
raise roundexception.RoundException("Invalid config file")
return tmpconfig
def get_available_assets(request):
"""Return JSON serializable dictionary with the number of matching assets
by media type and a list of available assets based on filter criteria passed in
request. If asset_id is passed, ignore other filters and return single
asset. If multiple, comma-separated values for asset_id are passed, ignore
other filters and return all those assets. If envelope_id is passed, ignore
other filters and return all assets in that envelope. If multiple,
comma-separated values for envelope_id are passed, ignore
other filters and return all those assets. Returns localized
value for tag strings on asset by asset basis unless a specific language
code is passed. Fall back to English if necessary."""
def _get_best_localized_string(asset, tag, best_lang_id):
""" Return localized string with specified language code.
If that's not available, look for a language field on the model and
use that. If that's not available, fall back to English.
"""
try:
localization = tag.loc_msg.get(language=best_lang_id)
except models.LocalizedString.DoesNotExist:
# try object's specified language
asset_lang = asset.language
if asset_lang and retlng != asset_lang:
localization = tag.loc_msg.get(language=asset_lang)
else:
# fall back to English
eng_id = models.Language.objects.get(language_code='en')
localization = tag.loc_msg.get(language=eng_id)
return localization.localized_string
form = request.GET
kw = {}
try:
hostname_without_port = str(
settings.config["external_host_name_without_port"])
except KeyError:
raise roundexception.RoundException(
"Roundware configuration file is missing 'external_host_name_without_port' key. "
)
known_params = [
'project_id', 'latitude', 'longitude', 'tag_ids', 'tagbool', 'radius',
'language', 'asset_id', 'envelope_id'
]
project_id = get_parameter_from_request(request, 'project_id', None)
asset_id = get_parameter_from_request(request, 'asset_id', None)
envelope_id = get_parameter_from_request(request, 'envelope_id', None)
latitude = get_parameter_from_request(request, 'latitude', None)
longitude = get_parameter_from_request(request, 'longitude', None)
radius = get_parameter_from_request(request, 'radius', None)
tag_ids = get_parameter_from_request(request, 'tagids', None)
tagbool = get_parameter_from_request(request, 'tagbool', None)
language = get_parameter_from_request(request, 'language', None)
if (latitude and not longitude) or (longitude and not latitude):
raise roundexception.RoundException(
"This operation requires that you pass both latitude and "
"longitude, if you pass either one.")
# accept other keyword parameters as long as the keys are fields on
# Asset model
asset_fields = models.get_field_names_from_model(models.Asset)
asset_media_types = [tup[0] for tup in models.Asset.ASSET_MEDIA_TYPES]
extraparams = [(param[0], param[1]) for param in form.items()
if param[0] not in known_params and param[0] in asset_fields
]
extras = {}
for k, v in extraparams:
extras[str(k)] = str(v)
# if a language (code) is specified, use that
# otherwise, return localized value specific to Asset
qry_retlng = None
if language:
try:
qry_retlng = models.Language.objects.get(language_code=language)
except models.Language.DoesNotExist:
raise roundexception.RoundException(
"Specified language code does not exist.")
if project_id or asset_id or envelope_id:
# by asset
if asset_id:
# ignore all other filter criteria
assets = models.Asset.objects.filter(id__in=asset_id.split(','))
# by envelope
elif envelope_id:
assets = []
envelopes = models.Envelope.objects.filter(
id__in=envelope_id.split(','))
for e in envelopes:
e_assets = e.assets.all()
for a in e_assets:
if a not in assets:
assets.append(a)
# by project
elif project_id:
project = models.Project.objects.get(id=project_id)
kw['project__exact'] = project
assets = models.Asset.objects.filter(**kw)
if tag_ids:
if tagbool and str(tagbool).lower() == 'or':
assets = assets.filter(
tags__in=tag_ids.split(',')).distinct()
else:
# 'and'. Asset must have all tags
for tag_id in tag_ids.split(','):
assets = assets.filter(tags__id=tag_id)
# filter by extra params. These are chained with an AND
assets = assets.filter(**extras)
if latitude and longitude: # need both
# return only assets within specified or default radius
# by project
latitude = float(latitude)
longitude = float(longitude)
if not radius:
radius = project.recording_radius
if not radius:
raise roundexception.RoundException(
"Project does not "
"specify a radius and no radius parameter passed to "
"operation.")
radius = float(radius)
for asset in assets:
distance = gpsmixer.distance_in_meters(
latitude, longitude, asset.latitude, asset.longitude)
if distance > radius:
assets = assets.exclude(id=asset.id)
assets_info = {}
assets_info['number_of_assets'] = {}
for mtype in asset_media_types:
assets_info['number_of_assets'][mtype] = 0
assets_list = []
for asset in assets:
if asset.mediatype in asset_media_types:
assets_info['number_of_assets'][asset.mediatype] += 1
if not qry_retlng:
retlng = asset.language # can be None
else:
retlng = qry_retlng
assets_list.append(
dict(asset_id=asset.id,
asset_url='%s%s' %
(rw_settings.AUDIO_FILE_URI, asset.filename),
latitude=asset.latitude,
longitude=asset.longitude,
audio_length=asset.audiolength,
submitted=asset.submitted,
project=asset.project.name,
language=asset.language.language_code,
tags=[
dict(tag_category_name=tag.tag_category.name,
tag_id=tag.id,
localized_value=_get_best_localized_string(
asset, tag, retlng))
for tag in asset.tags.all()
]), )
assets_info['assets'] = assets_list
return assets_info
else:
raise roundexception.RoundException(
"This operation requires that you "
"pass a project_id, asset_id, or envelope_id")
def request_stream(request):
request_form = request.GET
try:
hostname_without_port = str(
settings.config["external_host_name_without_port"])
except KeyError:
raise roundexception.RoundException(
"Roundware configuration file is missing 'external_host_name_without_port' key. "
)
db.log_event("request_stream", int(request_form['session_id']),
request_form)
if not request_form.get('session_id'):
raise roundexception.RoundException("Must supply session_id.")
session = models.Session.objects.select_related('project').get(
id=request_form.get('session_id'))
project = session.project
if session.demo_stream_enabled:
msg = "demo_stream_message"
try:
msg = project.demo_stream_message_loc.filter(
language=session.language)[0].localized_string
except:
pass
if project.demo_stream_url:
url = project.demo_stream_url
else:
url = "http://" + hostname_without_port + ":" + \
str(settings.config["icecast_port"]) + \
"/demo_stream.mp3"
return {'stream_url': url, 'demo_stream_message': msg}
elif is_listener_in_range_of_stream(request_form, project):
command = [
'/usr/local/bin/streamscript', '--session_id',
str(session.id), '--project_id',
str(project.id)
]
for p in ['latitude', 'longitude', 'audio_format']:
if request_form.has_key(p) and request_form[p]:
command.extend(['--' + p, request_form[p].replace("\t", ",")])
if request_form.has_key('config'):
command.extend([
'--configfile',
os.path.join(settings.configdir, request_form['config'])
])
else:
command.extend(
['--configfile',
os.path.join(settings.configdir, 'rw')])
if request_form.has_key('audio_stream_bitrate'):
command.extend([
'--audio_stream_bitrate',
str(request_form['audio_stream_bitrate'])
])
audio_format = project.audio_format.upper()
apache_safe_daemon_subprocess(command)
wait_for_stream(session.id, audio_format)
return {
"stream_url": "http://" + hostname_without_port + ":" + \
str(settings.config["icecast_port"]) + \
icecast_mount_point(session.id, audio_format),
}
else:
msg = "This application is designed to be used in specific geographic locations. Apparently your phone thinks you are not at one of those locations, so you will hear a sample audio stream instead of the real deal. If you think your phone is incorrect, please restart Scapes and it will probably work. Thanks for checking it out!"
try:
msg = project.out_of_range_message_loc.filter(
language=session.language)[0].localized_string
except:
pass
if project.out_of_range_url:
url = project.out_of_range_url
else:
url = "http://" + hostname_without_port + ":" + \
str(settings.config["icecast_port"]) + \
"/outofrange.mp3"
return {'stream_url': url, 'user_message': msg}
def add_asset_to_envelope(request):
#get asset_id from the GET request
asset_id = get_parameter_from_request(request, 'asset_id', False)
asset = None
#grab the Asset from the database, if an asset_id has been passed in
if asset_id:
try:
asset = models.Asset.objects.get(pk=asset_id)
except models.Asset.DoesNotExist:
raise roundexception.RoundException(
"Invalid Asset ID Provided. No Asset exists with ID %s" %
asset_id)
envelope_id = get_parameter_from_request(request, 'envelope_id', True)
envelope = models.Envelope.objects.select_related('session').get(
id=envelope_id)
session = envelope.session
db.log_event("start_upload", session.id, request.GET)
fileitem = request.FILES.get('file') if not asset else asset.file
#get mediatype from the GET request
mediatype = get_parameter_from_request(
request, 'mediatype', False) if not asset else asset.mediatype
#if mediatype parameter not passed, set to 'audio'
#this ensures backwards compatibility
if mediatype is None:
mediatype = "audio"
if fileitem.name:
#copy the file to a unique name (current time and date)
logging.debug("Processing " + fileitem.name)
(filename_prefix, filename_extension) = \
os.path.splitext(fileitem.name)
fn = time.strftime("%Y%m%d-%H%M%S") + filename_extension
fileout = open(os.path.join(settings.config["upload_dir"], fn), 'wb')
fileout.write(fileitem.file.read())
fileout.close()
#delete the uploaded original after the copy has been made
if asset:
asset.file.delete()
# re-assign file to asset
asset.file.name = fn
asset.filename = fn
asset.save()
#make sure everything is in wav form only if mediatype is audio
if mediatype == "audio":
newfilename = convertaudio.convert_uploaded_file(fn)
else:
newfilename = fn
if newfilename:
#create the new asset if request comes in from a source other
#than the django admin interface
if not asset:
#get location data from request
latitude = get_parameter_from_request(request, 'latitude',
False)
longitude = get_parameter_from_request(request, 'longitude',
False)
#if no location data in request, default to project latitude and longitude
if not latitude:
latitude = session.project.latitude
if not longitude:
longitude = session.project.longitude
tagset = []
tags = get_parameter_from_request(request, 'tags', False)
if tags is not None:
ids = tags.split(',')
tagset = models.Tag.objects.filter(id__in=ids)
# get optional submitted parameter from request (Y, N or blank string are only acceptable values)
submitted = get_parameter_from_request(request, 'submitted',
False)
# set submitted variable to proper boolean value if it is passed as parameter
if submitted == "N":
submitted = False
elif submitted == "Y":
submitted = True
# if blank string or not included as parameter, check if in range of project and if so
# set asset.submitted based on project.auto_submit boolean value
elif submitted is None or len(submitted) == 0:
submitted = False
if is_listener_in_range_of_stream(request.GET,
session.project):
submitted = session.project.auto_submit
asset = models.Asset(latitude=latitude,
longitude=longitude,
filename=newfilename,
session=session,
submitted=submitted,
mediatype=mediatype,
volume=1.0,
language=session.language,
project=session.project)
asset.file.name = fn
asset.save()
for t in tagset:
asset.tags.add(t)
#if the request comes from the django admin interface
#update the Asset with the right information
else:
#update asset with session
asset.session = session
asset.filename = newfilename
#get the audiolength of the file only if mediatype is audio and update the Asset
if mediatype == "audio":
discover_audiolength.discover_and_set_audiolength(
asset, newfilename)
asset.save()
envelope.assets.add(asset)
envelope.save()
else:
raise roundexception.RoundException(
"File not converted successfully: " + newfilename)
else:
raise roundexception.RoundException("No file in request")
rounddbus.emit_stream_signal(0, "refresh_recordings", "")
return {"success": True, "asset_id": asset.id}