#!/usr/bin/env python
import codecs, os, sys
import init_app   # Must import before any cameo or hazweb modules.
import config

os.umask(02)  # Create all files/sockets mode "rw-rw-r--".
if not os.environ.get("NO_LOG"):
    _logstream = open(config.error_log, "ab", 1)
    sys.stdout = _logstream
    sys.stderr = _logstream
    del _logstream

import errno,  os, signal, sys, time
from durus.client_storage import ClientStorage
from durus.connection import Connection
from durus.run_durus import start_durus, stop_durus
from durus.storage_server import SocketAddress
import quixote
from quixote.publish import Publisher
from quixote.server import scgi_server
from session2.SessionManager import SessionManager
from session2.store.DurusSessionStore import DurusSessionStore
import init_app
import config
from cameo.controllers.root import RootDirectory
from cameo.logger import CameoLogger
from cameo.model.cameo_api import Cameo
from cameo.session import Session

# SCGI parameters
HOST = "127.0.0.1"
PORT = 3004
MAX_CHILDREN = 3

quixote.DEFAULT_CHARSET = config.output_encoding
def session_manager():
    """For the multiuser web server."""
    storage = ClientStorage(address=config.sessions_socket)
    conn = Connection(storage, cache_size=100)
    store = DurusSessionStore(conn)
    return SessionManager(store, Session)

def create_publisher():
    logger = CameoLogger(
        access_log=config.access_log,
        error_log=None,  # Already handled at top of this module.
        error_email=None)
    publisher = Publisher(RootDirectory(),
        display_exceptions=config.display_exceptions,
        session_cookie_name="CAMEO_Session", 
        session_manager=session_manager(),
        logger=logger)
    config.cameo = Cameo(config.db_file, readonly=True)
    config.cameo.precache()
    return publisher

def log_friendly(func, *args, **kw):
    try:
        func(*args, **kw)
    except KeyboardInterrupt:
        pass  # Don't put unnecessary traceback in the log file.

def main():
    pid = os.fork()  # Raises OSError.
    if pid == 0:  # Child process.
        address = SocketAddress.new(address=config.sessions_socket)
        #print "In Durus process", os.getpid()
        log_friendly(start_durus, logfile=None, logginglevel=99, 
            file=config.sessions_file,
            repair=False, readonly=False, address=address)
        return
    # Parent process
    log_friendly(scgi_server.run, create_publisher, host=HOST, port=PORT,
        max_children=MAX_CHILDREN)
    try:
        os.kill(pid, signal.SIGTERM)
    except OSError, e:
        if e.errno != errno.NOSCH:  # No such process.        
            raise

if __name__ == "__main__":  main()