#!/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()