you_page_on_air_extended.py

import argparse

import django
import os
import traceback
from random import randint

parser = argparse.ArgumentParser()
text = 'Reco server is starting up'
parser.add_argument("--settings", "-s", help="facade settings")
parser.add_argument("--module", "-m", help="facade settings module")

args = parser.parse_args()
if args.settings is not None:
    settings = args.settings.strip()
else:
    settings = "facade.scripts_settings"
if args.module is not None:
    module = args.module.strip()
else:
    module = "siteadmin"
os.environ["DJANGO_SETTINGS_MODULE"] = settings
siteadmin = __import__(settings)
siteadmin = getattr(siteadmin, module)

print "settings is", settings
django.setup()
from flask import request, Flask
from waitress import serve

from partners.device_utils import DeviceUtils, PartnerConfig
from personalization_service.personalization.you_page.you_page_constants import lock_collection
from personalization_service.personalization.you_page.you_page_flask_api import build_response
from personalization_service.personalization.you_page.you_page_utils import parse_you_on_air_extended, STATUS_SUCCESS, \
    rcache, STATUS_FAILURE, sentry, parse_boolean
from personalization_service.personalization.you_page.youpage_library.on_air_extended import get_on_air_extended

app = Flask(__name__)


@app.route('/api/v4/epg/reco/episodes')
def get_you_on_air_extended():
    try:
        from google.auth import token_to_user_util
        auth_token = get_token_from_request()
        collection = get_collection_from_request()
        if auth_token is not None:
            try:
                user, _ = token_to_user_util(auth_token)
                user_id = user.id
            except Exception as e:
                sentry.user_context({
                    'requests.meta': get_all_request_meta(request),
                    'requests.params': request.args,
                    'requests.post': request.data,
                    'message': 'Auth Token Error'
                })
                sentry.captureException()
                user_id = -1
        else:
            user_id = request.args.get('user_id')
            if user_id is None:
                sentry.user_context({
                    'requests.meta': get_all_request_meta(request),
                    'requests.params': request.args,
                    'requests.post': request.data,
                    'message': 'Auth Token & user id not provided'
                })
                sentry.captureMessage('Auth Token & user id not provided')
                user_id = -1
        languages = request.args.get("languages", request.args.get("language", "English,Hindi"))
        languages = ",".join({l.title() for l in languages.split(",")})
        user_id, default_language, refresh = parse_you_on_air_extended(
            user_id,
            languages,
            request.args.get("refresh")
        )
        on_air_data, status, msg = get_on_air_extended(user_id, default_language, refresh, collection)
        if status == STATUS_SUCCESS:
            response = build_response(on_air_data, STATUS_SUCCESS)
            if randint(0, 100) == 0:
                rcache.set_timestamp("get_you_page_api_on_air_extended")
            engaged = parse_boolean(request.args.get('engaged'), True)
            if not engaged and not refresh:
                response.cache_control.max_age = 60*5
                response.cache_control.public = True
            return response
        else:
            return build_response({}, STATUS_FAILURE, error_message=msg)
    except Exception as e:
        traceback.print_exc()
        msg = "Something went wrong -- " + str(e.message)
        sentry.captureException()
        return build_response({}, STATUS_FAILURE, error_message=msg)


def get_token_from_request():
    token_ = request.headers.get('Authorization')
    if token_ is not None:
        return token_.replace("Token ", "")
    return None


def get_all_request_meta(request):
    meta = dict([(key, value) for key, value in request.headers.items()])
    return meta


def get_request_meta(request):
    meta = dict([(key, value) for key, value in request.headers.items() if key.startswith("X-")])
    return meta


def get_collection_from_request():
    collection = request.args.get("collection")
    if collection is not None:
        return collection
    # else get collection from headers
    try:
        meta = get_request_meta(request)
        package = meta.get('X-Api-Host')
        is_launcher = meta.get('X-App-Launcher') == "true"
        fingerprint = meta.get('X-Device-Fingerprint')
        product = meta.get('X-Device-Product')
        model = meta.get('X-Device-Model')
        manufacturer = meta.get('X-Device-Manufacturer')

        collection = util(fingerprint, is_launcher, manufacturer, model, package, product)
    except:
        return "default"
    return collection


@rcache.cache_function('device_utl_to_collection', 60 * 30, use_app_cache=True, app_cache_size=1000,
                       lock_and_get=lock_collection)
def util(fingerprint, is_launcher, manufacturer, model, package, product):
    device = DeviceUtils.get_device_from_params(package, is_launcher, fingerprint,
                                                product, model, manufacturer)
    collection = PartnerConfig(device.partner_product).get_channel_collection_filter()
    return collection


def start_flask(port):
    serve(app, host='0.0.0.0', port=port, threads=1)


if __name__ == '__main__':
    start_flask(8016)
    # http_server = HTTPServer(WSGIContainer(app))
    # http_server.bind(18790)
    # http_server.start(0)
    # IOLoop.current().start()