#!/usr/bin/env python

from __future__ import with_statement

from time import time, sleep

import threading

import logging

from pyload.utils.fs import exists

core = None

setup = None

log = logging.getLogger("log")

class WebServer(threading.Thread):

def __init__(self, pycore=None, pysetup=None):

global core, setup

threading.Thread.__init__(self)

if pycore:

core = pycore

config = pycore.config

elif pysetup:

setup = pysetup

config = pysetup.config

else:

raise Exception("No config context provided")

self.server = config['webUI']['server']

self.https = config['webUI']['https']

self.cert = config["ssl"]["cert"]

self.key = config["ssl"]["key"]

self.host = config['webUI']['host']

self.port = config['webUI']['port']

self.debug = config['general']['debug_mode']

self.force_server = config['webUI']['force_server']

self.error = None

self.setDaemon(True)

def run(self):

self.running = True

import webinterface

global webinterface

if self.https:

if not exists(self.cert) or not exists(self.key):

log.warning(_("SSL certificates not found."))

self.https = False

if webinterface.UNAVAILALBE:

log.warning(_("WebUI built is not available"))

elif webinterface.APP_PATH == "app":

log.info(_("Running webUI in development mode"))

prefer = None

# These cases covers all settings

if self.server == "threaded":

prefer = "threaded"

elif self.server == "fastcgi":

prefer = "flup"

elif self.server == "fallback":

prefer = "wsgiref"

server = self.select_server(prefer)

try:

self.start_server(server)

except Exception, e:

log.error(_("Failed starting webserver: " + e.message))

self.error = e

if core:

core.print_exc()

def select_server(self, prefer=None):

""" find a working server """

from servers import all_server

unavailable = []

server = None

for server in all_server:

if self.force_server and self.force_server == server.NAME:

break # Found server

# When force_server is set, no further checks have to be made

elif self.force_server:

continue

if prefer and prefer == server.NAME:

break # found prefered server

elif prefer: # prefer is similar to force, but force has precedence

continue

# Filter for server that offer ssl if needed

if self.https and not server.SSL:

continue

try:

if server.find():

break # Found a server

else:

unavailable.append(server.NAME)

except Exception, e:

log.error(_("Failed importing webserver: " + e.message))

if unavailable: # Just log whats not available to have some debug information

log.debug("Unavailable webserver: " + ", ".join(unavailable))

if not server and self.force_server:

server = self.force_server # just return the name

return server

def start_server(self, server):

from servers import ServerAdapter

if issubclass(server, ServerAdapter):

if self.https and not server.SSL:

log.warning(_("This server offers no SSL, please consider using threaded instead"))

elif not self.https:

self.cert = self.key = None # This implicitly disables SSL

# there is no extra argument for the server adapter

# TODO: check for openSSL ?

# Now instantiate the serverAdapter

server = server(self.host, self.port, self.key, self.cert, 6, self.debug) # todo, num_connections

name = server.NAME

else: # server is just a string

name = server

log.info(

_("Starting %(name)s webserver: %(host)s:%(port)d") % {"name": name, "host": self.host, "port": self.port})

webinterface.run_server(host=self.host, port=self.port, server=server)

# check if an error was raised for n seconds

def check_error(self, n=1):

t = time() + n

while time() < t:

if self.error:

return self.error

sleep(0.1)