"""Run a Quixote application with the server of your choice.

KLUDGES:
- After daemonize() call, do "os._urandomfd = None".  Otherwise you get a "bad
  file descriptor" error sometimes (observed on Mac OS X).  Apparently
  os.urandom() is called before the fork, and the file descriptor is invalid in
  the child.
"""
import errno, grp, os, pwd, signal, sys
from optparse import OptionParser
from quixote.publish import Publisher

#### PUBLIC FUNCTIONS ####
def main_part1():
    # The config module sets up database connections, so we can't import it
    # till after we daemonize.
    parser = make_parser()
    opts, args = parser.parse_args()
    errmsg = check_usage(opts, args)
    if errmsg:
        print "ERROR:", errmsg
        parser.print_help()
        sys.exit(1)
    change_user(opts.user, opts.group)
    if opts.stop:
        stop(opts.pidfile)    # Exits program, does not return.
    if opts.daemon:
        daemon(opts.pidfile)
    return opts.scgi

def main_part2(root_directory, config, is_scgi):
    C = config
    if is_scgi:
        access_log = C.scgi.access_log
        error_log = C.scgi.error_log
    else:
        access_log = None   # No access log.
        error_log = None    # Send errors to standard error.

    def create_publisher():  # Inner function.
        return Publisher(root_directory,
            session_manager=C.session.manager,
            display_exceptions=C.display_exceptions,
            access_log=access_log,
            error_log=error_log)

    if is_scgi:
        mp_safe = C.session.store.is_multiprocess_safe
        if C.scgi.max_children > 1 and not mp_safe:
            m = "configured session store is unsafe for multiple SCGI children"
            raise RuntimeError(m)
        scgi(create_publisher, C.scgi.port, C.scgi.script_name, 
            C.scgi.max_children)
    else:
        simple(create_publisher, C.simple.host, C.simple.port, C.htTitle)

#### OPTIONS-PARSING FUNCTIONS ####
def make_parser():
    parser = OptionParser()
    pao = parser.add_option
    pao('--simple', action="store_true", dest="simple", 
        help="Run under the simple server")
    pao('--scgi', action="store_true", dest="scgi", 
        help="Run under the SCGI server")
    pao('--daemon', action="store_true", dest="daemon",
        help="Run as system service (daemon) (requires --pidfile)")
    pao('--stop', action="store_true", dest="stop",
        help="Stop a running daemon (requires --pidfile)")
    pao('--pidfile', action="store", dest="pidfile",
        help="Record daemon PID in this file")
    pao('--user', action="store", dest="user",
        help="Run as this user (name or UID)")
    pao('--group', action="store", dest="group",
        help="Run as this group (name or GID)")
    return parser

def check_usage(opts, args):
    if (not opts.stop) and count_true(opts.scgi, opts.simple) != 1:
        return "must specify --simple or --scgi flag (but not both)"
    if opts.daemon and opts.stop:
        return "can't specify both --daemon and --stop"
    if opts.daemon and not opts.pidfile:
        return "--daemon requires --pidfile"
    if opts.stop and not opts.pidfile:
        return "--stop requires --pidfile"
    if opts.stop and opts.pidfile and not os.path.exists(opts.pidfile):
        return "--pidfile refers to non-existent file"
    return None

def count_true(*values):
    """Return the number of true values."""
    return len(filter(None, values))

#### SERVER FUNCTIONS ####
def scgi(create_publisher, port, script_name, max_children):
    from quixote.server import scgi_server
    scgi_server.run(create_publisher, port=port, 
        script_name=script_name, max_children=max_children)

def simple(create_publisher, host, port, title):
    from quixote.server import simple_server
    tup = title, host or "[ALL INTERFACES]", port
    print "%s listening on http://%s:%s/" % tup
    try:
        simple_server.run(create_publisher, host=host, port=port)
    except KeyboardInterrupt:
        print "Exiting.  (Ctrl-C pressed.)"

#### USER-CHANGING FUNCTIONS ####
def change_user(user=None, group=None):
    # JJ Behrens says we must set the group first, so we do.
    if group is not None:
        if group.isdigit():
            gid = int(group)
        else:
            gid = grp.getgrnam(group)[2]
        os.setegid(gid)
    if user is not None:
        if user.isdigit():
            uid = int(user)
        else:
            uid = pwd.getpwnam(user)[2]
        os.seteuid(uid)

#### DAEMON FUNCTIONS ####
def daemon(pidfile):
    if os.path.exists(pidfile):
        pid = read_pidfile(pidfile)
        if process_exists(pid):
            msg = "daemon already running (PID %s, file %s)" % (pid, pidfile)
            sys.exit(msg)
    daemonize()
    os._urandomfd = None  # @@MO: Workaround for Mac OS X (see docstring).
    write_pidfile(pidfile)

def stop(pidfile):
    pid = read_pidfile(pidfile)
    try:
        os.kill(pid, signal.SIGTERM)
    except OSError, e:
        if e.errno == errno.ESRCH: # No such process.
            sys.exit(1)   
        else:
            raise
    # Signal delivered, delete pidfile and exit program.
    os.remove(pidfile)
    sys.exit(0)     

#### DAEMON UTILITY FUNCTIONS ####
def read_pidfile(pidfile):
    f = open(pidfile, 'r')
    pid = f.read()
    f.close()
    try:
        pid = int(pid)
    except ValueError:
        msg = "corrupt PID file %s (content not numeric)" % pidfile
        raise RuntimeError(message)
    return pid
        
def write_pidfile(pidfile):
    pid = os.getpid()
    f = open(pidfile, 'w')
    print >>f, pid
    f.close()

def process_exists(pid):
    try:
        os.kill(pid, 0)
    except OSError, e:
        if e.errno == errno.ESRCH:
            return False
        else:
            raise
    return True

def daemonize():
    """Detach a process from the controlling terminal and run it in the
       background as a daemon.  A Python Cookbook recipe by Chad J Schroeder.
       http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/278731
       Original documentation follows.

       Disk And Execution MONitor (Daemon)
   
       Default daemon behaviors (they can be modified):
          1.) Ignore SIGHUP signals.
          2.) Default current working directory to the "/" directory.
       #  3.) Set the current file creation mode mask to 0.
          4.) Close all open files (0 to [SC_OPEN_MAX or 256]).
          5.) Redirect standard I/O streams to "/dev/null".
   
       [# indicates behaviors disabled in this version.]

       Failed fork() calls will return a tuple: (errno, strerror).  This
       behavior can be modified to meet your program's needs.
   
       Resources:
          Advanced Programming in the Unix Environment: W. Richard Stevens
          Unix Network Programming (Volume 1): W. Richard Stevens
          http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
    """
    try:
       # Fork a child process so the parent can exit.  This will return control
       # to the command line or shell.  This is required so that the new process
       # is guaranteed not to be a process group leader.  We have this guarantee
       # because the process GID of the parent is inherited by the child, but
       # the child gets a new PID, making it impossible for its PID to equal its
       # PGID.
       pid = os.fork()
    except OSError, e:
       return((e.errno, e.strerror))     # ERROR (return a tuple)
 
    if (pid == 0):       # The first child.
 
       # Next we call os.setsid() to become the session leader of this new
       # session.  The process also becomes the process group leader of the
       # new process group.  Since a controlling terminal is associated with a
       # session, and this new session has not yet acquired a controlling
       # terminal our process now has no controlling terminal.  This shouldn't
       # fail, since we're guaranteed that the child is not a process group
       # leader.
       os.setsid()
 
       # When the first child terminates, all processes in the second child
       # are sent a SIGHUP, so it's ignored.
       signal.signal(signal.SIGHUP, signal.SIG_IGN)
 
       try:
          # Fork a second child to prevent zombies.  Since the first child is
          # a session leader without a controlling terminal, it's possible for
          # it to acquire one by opening a terminal in the future.  This second
          # fork guarantees that the child is no longer a session leader, thus
          # preventing the daemon from ever acquiring a controlling terminal.
          pid = os.fork()        # Fork a second child.
       except OSError, e:
          return((e.errno, e.strerror))  # ERROR (return a tuple)
 
       if (pid == 0):      # The second child.
          # Ensure that the daemon doesn't keep any directory in use.  Failure
          # to do this could make a filesystem unmountable.
          os.chdir("/")
          # Give the child complete control over permissions.
          os.umask(0)
       else:
          os._exit(0)      # Exit parent (the first child) of the second child.
    else:
       os._exit(0)         # Exit parent of the first child.
 
    # Close all open files.  Try the system configuration variable, SC_OPEN_MAX,
    # for the maximum number of open files to close.  If it doesn't exist, use
    # the default value (configurable).
    try:
       maxfd = os.sysconf("SC_OPEN_MAX")
    except (AttributeError, ValueError):
       maxfd = 256       # default maximum
 
    for fd in range(0, maxfd):
       try:
          os.close(fd)
       except OSError:   # ERROR (ignore)
          pass
 
    # Redirect the standard file descriptors to /dev/null.
    os.open("/dev/null", os.O_RDONLY)    # standard input (0)
    os.open("/dev/null", os.O_RDWR)       # standard output (1)
    os.open("/dev/null", os.O_RDWR)       # standard error (2)
 
    return(0)