# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""twisted server for CubicWeb web instances"""

from __future__ import with_statement

__docformat__ = "restructuredtext en"

import sys

import os

import os.path as osp

import select

import traceback

import threading

import re

from hashlib import md5 # pylint: disable=E0611

from os.path import join

from time import mktime

from datetime import date, timedelta

from urlparse import urlsplit, urlunsplit

from cgi import FieldStorage, parse_header

from cStringIO import StringIO

from twisted.internet import reactor, task, threads

from twisted.internet.defer import maybeDeferred

from twisted.web import http, server

from twisted.web import static, resource

from twisted.web.server import NOT_DONE_YET

from logilab.common.decorators import monkeypatch

from cubicweb import (AuthenticationError, ConfigurationError,

                      CW_EVENT_MANAGER, CubicWebException)

from cubicweb.utils import json_dumps

from cubicweb.web import Redirect, DirectResponse, StatusResponse, LogOut

from cubicweb.web.application import CubicWebPublisher

from cubicweb.web.http_headers import generateDateTime

from cubicweb.etwist.request import CubicWebTwistedRequestAdapter

from cubicweb.etwist.http import HTTPResponse

def start_task(interval, func):

    lc = task.LoopingCall(func)

    # wait until interval has expired to actually start the task, else we have

    # to wait all task to be finished for the server to be actually started

    lc.start(interval, now=False)

def host_prefixed_baseurl(baseurl, host):

    scheme, netloc, url, query, fragment = urlsplit(baseurl)

    netloc_domain = '.' + '.'.join(netloc.split('.')[-2:])

    if host.endswith(netloc_domain):

        netloc = host

    baseurl = urlunsplit((scheme, netloc, url, query, fragment))

    return baseurl

class ForbiddenDirectoryLister(resource.Resource):

    def render(self, request):

        return HTTPResponse(twisted_request=request,

                            code=http.FORBIDDEN,

                            stream='Access forbidden')

class NoListingFile(static.File):

    def __init__(self, config, path=None):

        if path is None:

            path = config.static_directory

        static.File.__init__(self, path)

        self.config = config

    def set_expires(self, request):

        if not self.config.debugmode:

            # XXX: Don't provide additional resource information to error responses

            #

            # the HTTP RFC recommands not going further than 1 year ahead

            expires = date.today() + timedelta(days=6*30)

            request.setHeader('Expires', generateDateTime(mktime(expires.timetuple())))

    def directoryListing(self):

        return ForbiddenDirectoryLister()

class DataLookupDirectory(NoListingFile):

    def __init__(self, config, path):

        self.md5_version = config.instance_md5_version()

        NoListingFile.__init__(self, config, path)

        self.here = path

        self._defineChildResources()

        if self.config.debugmode:

            self.data_modconcat_basepath = '/data/??'

        else:

            self.data_modconcat_basepath = '/data/%s/??' % self.md5_version

    def _defineChildResources(self):

        self.putChild(self.md5_version, self)

    def getChild(self, path, request):

        if not path:

            uri = request.uri

            if uri.startswith('/https/'):

                uri = uri[6:]

            if uri.startswith(self.data_modconcat_basepath):

                resource_relpath = uri[len(self.data_modconcat_basepath):]

                if resource_relpath:

                    paths = resource_relpath.split(',')

                    try:

                        self.set_expires(request)

                        return ConcatFiles(self.config, paths)

                    except ConcatFileNotFoundError:

                        return self.childNotFound

            return self.directoryListing()

        childpath = join(self.here, path)

        dirpath, rid = self.config.locate_resource(childpath)

        if dirpath is None:

            # resource not found

            return self.childNotFound

        filepath = os.path.join(dirpath, rid)

        if os.path.isdir(filepath):

            resource = DataLookupDirectory(self.config, childpath)

            # cache resource for this segment path to avoid recomputing

            # directory lookup

            self.putChild(path, resource)

            return resource

        else:

            self.set_expires(request)

            return NoListingFile(self.config, filepath)

class FCKEditorResource(NoListingFile):

    def getChild(self, path, request):

        pre_path = request.path.split('/')[1:]

        if pre_path[0] == 'https':

            pre_path.pop(0)

            uiprops = self.config.https_uiprops

        else:

            uiprops = self.config.uiprops

        return static.File(osp.join(uiprops['FCKEDITOR_PATH'], path))

class LongTimeExpiringFile(DataLookupDirectory):

    """overrides static.File and sets a far future ``Expires`` date

    on the resouce.

    versions handling is done by serving static files by different

    URLs for each version. For instance::

      http://localhost:8080/data-2.48.2/cubicweb.css

      http://localhost:8080/data-2.49.0/cubicweb.css

      etc.

    """

    def _defineChildResources(self):

        pass

class ConcatFileNotFoundError(CubicWebException):

    pass

class ConcatFiles(LongTimeExpiringFile):

    def __init__(self, config, paths):

        _, ext = osp.splitext(paths[0])

        self._resources = {}

        # create a unique / predictable filename. We don't consider cubes

        # version since uicache is cleared at server startup, and file's dates

        # are checked in debug mode

        fname = 'cache_concat_' + md5(';'.join(paths)).hexdigest() + ext

        filepath = osp.join(config.appdatahome, 'uicache', fname)

        LongTimeExpiringFile.__init__(self, config, filepath)

        self._concat_cached_filepath(filepath, paths)

    def _resource(self, path):

        try:

            return self._resources[path]

        except KeyError:

            self._resources[path] = self.config.locate_resource(path)

            return self._resources[path]

    def _concat_cached_filepath(self, filepath, paths):

        if not self._up_to_date(filepath, paths):

            with open(filepath, 'wb') as f:

                for path in paths:

                    dirpath, rid = self._resource(path)

                    if rid is None:

                        # In production mode log an error, do not return a 404

                        # XXX the erroneous content is cached anyway

                        LOGGER.error('concatenated data url error: %r file '

                                     'does not exist', path)

                        if self.config.debugmode:

                            raise ConcatFileNotFoundError(path)

                    else:

                        for line in open(osp.join(dirpath, rid)):

                            f.write(line)

                        f.write('\n')

    def _up_to_date(self, filepath, paths):

        """

        The concat-file is considered up-to-date if it exists.

        In debug mode, an additional check is performed to make sure that

        concat-file is more recent than all concatenated files

        """

        if not osp.isfile(filepath):

            return False

        if self.config.debugmode:

            concat_lastmod = os.stat(filepath).st_mtime

            for path in paths:

                dirpath, rid = self._resource(path)

                if rid is None:

                    raise ConcatFileNotFoundError(path)

                path = osp.join(dirpath, rid)

                if os.stat(path).st_mtime > concat_lastmod:

                    return False

        return True

class CubicWebRootResource(resource.Resource):

    def __init__(self, config, vreg=None):

        resource.Resource.__init__(self)

        self.config = config

        # instantiate publisher here and not in init_publisher to get some

        # checks done before daemonization (eg versions consistency)

        self.appli = CubicWebPublisher(config, vreg=vreg)

        self.base_url = config['base-url']

        self.https_url = config['https-url']

        global MAX_POST_LENGTH

        MAX_POST_LENGTH = config['max-post-length']

        self.putChild('static', NoListingFile(config))

        self.putChild('fckeditor', FCKEditorResource(self.config, ''))

        self.putChild('data', DataLookupDirectory(self.config, ''))

    def init_publisher(self):

        config = self.config

        # when we have an in-memory repository, clean unused sessions every XX

        # seconds and properly shutdown the server

        if config.repo_method == 'inmemory':

            if config.pyro_enabled():

                # if pyro is enabled, we have to register to the pyro name

                # server, create a pyro daemon, and create a task to handle pyro

                # requests

                self.pyro_daemon = self.appli.repo.pyro_register()

                self.pyro_listen_timeout = 0.02

                self.appli.repo.looping_task(1, self.pyro_loop_event)

            if config.mode != 'test':

                reactor.addSystemEventTrigger('before', 'shutdown',

                                              self.shutdown_event)

                self.appli.repo.start_looping_tasks()

        self.set_url_rewriter()

        CW_EVENT_MANAGER.bind('after-registry-reload', self.set_url_rewriter)

    def start_service(self):

        start_task(self.appli.session_handler.clean_sessions_interval,

                   self.appli.session_handler.clean_sessions)

    def set_url_rewriter(self):

        self.url_rewriter = self.appli.vreg['components'].select_or_none('urlrewriter')

    def shutdown_event(self):

        """callback fired when the server is shutting down to properly

        clean opened sessions

        """

        self.appli.repo.shutdown()

    def pyro_loop_event(self):

        """listen for pyro events"""

        try:

            self.pyro_daemon.handleRequests(self.pyro_listen_timeout)

        except select.error:

            return

    def getChild(self, path, request):

        """Indicate which resource to use to process down the URL's path"""

        return self

    def render(self, request):

        """Render a page from the root resource"""

        # reload modified files in debug mode

        if self.config.debugmode:

            self.config.uiprops.reload_if_needed()

            if self.https_url:

                self.config.https_uiprops.reload_if_needed()

            self.appli.vreg.reload_if_needed()

        if self.config['profile']: # default profiler don't trace threads

            return self.render_request(request)

        else:

            deferred = threads.deferToThread(self.render_request, request)

            return NOT_DONE_YET

    def render_request(self, request):

        try:

            # processing HUGE files (hundred of megabytes) in http.processReceived

            # blocks other HTTP requests processing

            # due to the clumsy & slow parsing algorithm of cgi.FieldStorage

            # so we deferred that part to the cubicweb thread

            request.process_multipart()

            return self._render_request(request)

        except Exception:

            errorstream = StringIO()

            traceback.print_exc(file=errorstream)

            return HTTPResponse(stream='<pre>%s</pre>' % errorstream.getvalue(),

                                code=500, twisted_request=request)

    def _render_request(self, request):

        origpath = request.path

        host = request.host

        # dual http/https access handling: expect a rewrite rule to prepend

        # 'https' to the path to detect https access

        if origpath.split('/', 2)[1] == 'https':

            origpath = origpath[6:]

            request.uri = request.uri[6:]

            https = True

            baseurl = self.https_url or self.base_url

        else:

            https = False

            baseurl = self.base_url

        if self.config['use-request-subdomain']:

            baseurl = host_prefixed_baseurl(baseurl, host)

            self.warning('used baseurl is %s for this request', baseurl)

        req = CubicWebTwistedRequestAdapter(request, self.appli.vreg, https, baseurl)

        if req.authmode == 'http':

            # activate realm-based auth

            realm = self.config['realm']

            req.set_header('WWW-Authenticate', [('Basic', {'realm' : realm })], raw=False)

        try:

            self.appli.connect(req)

        except Redirect, ex:

            return self.redirect(request=req, location=ex.location)

        if https and req.session.anonymous_session:

            # don't allow anonymous on https connection

            return self.request_auth(request=req)

        if self.url_rewriter is not None:

            # XXX should occur before authentication?

            try:

                path = self.url_rewriter.rewrite(host, origpath, req)

            except Redirect, ex:

                return self.redirect(req, ex.location)

            request.uri.replace(origpath, path, 1)

        else:

            path = origpath

        if not path or path == "/":

            path = 'view'

        try:

            result = self.appli.publish(path, req)

        except DirectResponse, ex:

            return ex.response

        except StatusResponse, ex:

            return HTTPResponse(stream=ex.content, code=ex.status,

                                twisted_request=req._twreq,

                                headers=req.headers_out)

        except AuthenticationError:

            return self.request_auth(request=req)

        except LogOut, ex:

            if self.config['auth-mode'] == 'cookie' and ex.url:

                return self.redirect(request=req, location=ex.url)

            # in http we have to request auth to flush current http auth

            # information

            return self.request_auth(request=req, loggedout=True)

        except Redirect, ex:

            return self.redirect(request=req, location=ex.location)