#!/usr/bin/env python

__author__ = "Gustavo Sverzut Barbieri / Artur Duque de Souza"

__author_email__ = "barbieri@gmail.com / artur.souza@indt.org.br"

__license__ = "GPL"

__version__ = "0.4"

import os

import threading

import SocketServer

import BaseHTTPServer

import socket

import urlparse

import cgi

import lib.utils as utils

import logging

from log import Log

from request_handler import RequestHandler

__all__ = ("Server", "serve_forever", "load_plugins_transcoders")

class Server(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):

    log = logging.getLogger("gms.server")

    last_tid = 0

    run = True

    _transcoders = {}

    _lock = threading.RLock()

    def serve_forever(self):

        self.log.info("GMyth-Streamer serving HTTP on %s:%s" %

                      self.socket.getsockname())

        try:

            while self.run:

                self.handle_request()

        except KeyboardInterrupt, e:

            pass

        self.log.debug("Stopping all remaining transcoders...")

        self.stop_transcoders()

        self.log.debug("Transcoders stopped!")

    # serve_forever()

    def get_request(self):

        skt = self.socket

        old = skt.gettimeout()

        skt.settimeout(0.5)

        while self.run:

            try:

                r = skt.accept()

                skt.settimeout(old)

                return r

            except socket.timeout, e:

                pass

        raise socket.error("Not running")

    # get_request()

    def server_close(self):

        self.run = False

        self.stop_transcoders()

        BaseHTTPServer.HTTPServer.server_close(self)

    # server_close()

    def stop_transcoders(self):

        self._lock.acquire()

        for transcoder, request in self._transcoders.iteritems():

            self.log.info("Stop transcoder: %s, client=%s" %

                          (transcoder, request.client_address))

            transcoder.stop()

        self._lock.release()

    # stop_transcoders()

    def get_transcoders(self):

        self._lock.acquire()

        try:

            return self._transcoders.items()

        finally:

            self._lock.release()

    # get_transcoders()

    def add_transcoders(self, request, transcoder):

        self._lock.acquire()

        try:

            self._transcoders[transcoder] = request

        finally:

            self._lock.release()

    # add_transcoders()

    def del_transcoders(self, request, transcoder):

        self._lock.acquire()

        try:

            del self._transcoders[transcoder]

        finally:

            self._lock.release()

    # del_transcoders()

# Server

def serve_forever(host="0.0.0.0", port=40000):

    addr = (host, port)

    RequestHandler.protocol_version = "HTTP/1.0"

    httpd = Server(addr, RequestHandler)

    httpd.serve_forever()

# serve_forever()

def load_plugins_transcoders(directory):

    RequestHandler.load_plugins_transcoders(directory)

# load_plugins_transcoders()