grooveondemand/groove/webserver/webserver.py

import logging
import json
import os

import bottle
from bottle import HTTPResponse, template, static_file
from bottle.ext import sqlalchemy
from sqlalchemy.exc import NoResultFound, MultipleResultsFound

import groove.db
from groove.auth import is_authenticated
from groove.db.manager import database_manager
from groove.playlist import Playlist
from groove.webserver import requests, themes

server = bottle.Bottle()


def start(host: str = '127.0.0.1', port: int = 2323, debug: bool = False) -> None:  # pragma: no cover
    """
    Start the Bottle app.
    """
    logging.debug(f"Configuring sqllite using {os.environ.get('DATABASE_PATH')}")

    with database_manager() as manager:
        server.install(sqlalchemy.Plugin(
            manager.engine,
            groove.db.metadata,
            keyword='db',
            create=True,
            commit=True,
        ))
        logging.debug(f"Configuring webserver with host={host}, port={port}, debug={debug}")
        server.run(
            host=os.getenv('HOST', host),
            port=os.getenv('PORT', port),
            debug=debug,
            server='paste',
            quiet=True
        )


def serve(template_name, theme=None, **template_args):
    theme = themes.load_theme(theme)
    return HTTPResponse(status=200, body=template(
        str(theme.path / groove.path.theme_template(template_name)),
        url=requests.url(),
        theme=theme,
        **template_args
    ))


@server.route('/')
def index():
    return "Groovy."


@server.route('/static/<filepath:path>')
def serve_static(filepath):
    theme = themes.load_theme()
    path = groove.path.static(filepath, theme=theme)
    logging.debug(f"Serving asset {path.name} from {path.parent}")
    return static_file(path.name, root=path.parent)


@server.route('/track/<request>/<track_id>')
def serve_track(request, track_id, db):

    expected = requests.encode([track_id], '/track')
    if not requests.verify(request, expected):  # pragma: no cover
        return HTTPResponse(status=404, body="Not found")

    try:
        track_id = int(track_id)
        track = db.query(groove.db.track).filter(
            groove.db.track.c.id == track_id
        ).one()
    except (NoResultFound, MultipleResultsFound):
        return HTTPResponse(status=404, body="Not found")

    path = groove.path.transcoded_media(track['relpath'])
    if not path.exists():
        path = groove.path.media(track['relpath'])
    logging.debug(f"Serving track {path.name}")
    return static_file(path.name, root=path.parent)


@server.route('/playlist/<slug>')
def serve_playlist(slug, db):
    """
    Retrieve a playlist and its entries by a slug.
    """
    logging.debug(f"Looking up playlist: {slug}...")
    try:
        playlist = Playlist.by_slug(slug, session=db)
    except NoResultFound:
        logging.debug(f"Playist {slug} doesn't exist.")
        return HTTPResponse(status=404, body="Not found")
    logging.debug(f"Loaded {playlist.record}")
    logging.debug(playlist.as_dict['entries'])

    pl = playlist.as_dict
    for entry in pl['entries']:
        sig = requests.encode([str(entry['track_id'])], uri='/track')
        entry['url'] = f"/track/{sig}/{entry['track_id']}"

    return serve('playlist', playlist=pl)


@server.route('/build')
@bottle.auth_basic(is_authenticated)
def build():
    return "Authenticated. Groovy."


@bottle.auth_basic(is_authenticated)
@server.route('/build/search/playlist/<slug>')
def search_playlist(slug, db):
    try:
        playlist = Playlist.by_slug(slug, session=db)
    except NoResultFound:
        logging.debug(f"Playlist {slug} doesn't exist.")
        body = {}
    else:
        body = json.dumps(playlist.as_dict)
    return HTTPResponse(status=200, content_type='application/json', body=body)