Ticket #1736: django-management-fastcgi.diff

core/management.py

@@ -997 +997 @@
     autoreload.main(inner_run)
 runserver.args = '[optional port number, or ipaddr:port]'
 
+FASTCGI_HELP = r"""runfcgi:
+  Run this project as a fastcgi application. To do this, the
+  flup package from http://www.saddi.com/software/flup/ is
+  required.
+
+Usage:
+   django-admin.py runfcgi --setttings=yourproject.settings [fcgi settings]
+   manage.py runfcgi [fcgi settings]
+     
+Optional Fcgi settings: (setting=value)
+  host=HOSTNAME        hostname to listen on..
+  port=PORTNUM         port to listen on.
+  socket=FILE          UNIX socket to listen on.
+  method=IMPL          prefork or threaded (default prefork)
+  maxspare=NUMBER      max number of spare processes to keep running.
+  minspare=NUMBER      min number of spare processes to prefork.
+  maxchildren=NUMBER   hard limit number of processes in prefork mode.
+  daemonize=BOOL       whether to detach from terminal.
+  pidfile=FILE         write the spawned process-id to this file.
+  workdir=DIRECTORY    change to this directory when daemonizing
+
+Examples:
+  Run a "standard" fastcgi process on a file-descriptor 
+  (for webservers which spawn your processes for you)
+    $ manage.py runfcgi method=threaded
+
+  Run a fastcgi server on a TCP host/port
+    $ manage.py runfcgi method=prefork host=127.0.0.1 port=8025
+
+  Run a fastcgi server on a UNIX domain socket (posix platforms only)
+    $ manage.py runfcgi method=prefork socket=/tmp/fcgi.sock
+
+  Run a fastCGI as a daemon and write the spawned PID in a file
+    $ manage.py runfcgi socket=/tmp/fcgi.sock method=prefork \
+        daemonize=true pidfile=/var/run/django-fcgi.pid
+  
+"""
+
+def fastcgi_help(message = None):
+    print FASTCGI_HELP
+    if message:
+        print message
+    return False
+
+FASTCGI_OPTIONS = {
+    'host': None,
+    'port': None,
+    'socket': None,
+    'method': 'fork',
+    'daemonize': None,
+    'workdir': '.',
+    'pidfile': None,
+    'maxspare': 5,
+    'minspare': 2,
+    'maxchildren': 50,
+}
+
+def runfastcgi(argset):
+    """Run this project as a FastCGI application. requires flup."""
+    options = FASTCGI_OPTIONS.copy()
+    for x in argset:
+        if "=" in x:
+            k, v = x.split('=', 1)
+        else:
+            k,v = x, True
+        options[k.lower()] = v
+
+    if "help" in options:
+        return fastcgi_help()
+
+    try:
+        import flup
+    except ImportError, e:
+        print >> sys.stderr, "ERROR: %s" % e
+        print >> sys.stderr, "  Unable to load the flup package.  In order to run django"
+        print >> sys.stderr, "  as a FastCGI application, you will need to get flup from"
+        print >> sys.stderr, "  http://www.saddi.com/software/flup/   If you have flup already"
+        print >> sys.stderr, "  installed, then make sure you have it in your pythonpath."
+        return False
+        
+    if options['method'] in ('prefork', 'fork'):
+        from flup.server.fcgi_fork import WSGIServer
+        wsgi_opts = dict(
+            maxSpare = int(options["maxspare"]),
+            minSpare = int(options["minspare"]),
+            maxChildren = int(options["maxchildren"]),
+        )
+    elif options['method'] in ('thread', 'threaded'):
+        from flup.server.fcgi import WSGIServer 
+        wsgi_opts = {}
+    else:
+        return fastcgi_help("ERROR: implementation must be one of prefork or thread")
+
+    # prep up and go
+    from django.core.handlers.wsgi import WSGIHandler
+
+    if options["host"] and options["port"] and not options["socket"]:
+        wsgi_opts['bindAddress'] = (options["host"], int(options["port"]))
+    elif options["socket"] and not options["host"] and not options["port"]:
+        wsgi_opts['bindAddress'] = options["socket"]
+    elif not options["socket"] and not options["host"] and not options["port"]:
+        wsgi_opts['bindAddress'] = None
+    else:
+        return fastcgi_help("invalid combination of host,port,socket.")
+
+    if options["daemonize"] is None:
+        # default to daemonizing if we are running as a daemon process
+        daemonize = (wsgi_opts['bindAddress'] is not None) 
+    else:
+        if options["daemonize"].lower() in ('true', 'yes', 't'):
+            daemonize = True
+        elif options["daemonize"].lower() in ('false', 'no', 'f'):
+            daemonize = False
+        else:
+            return fastcgi_help("ERROR: invalid option for daemonize parameter")
+    
+    if daemonize:
+        from django.utils.daemonize import become_daemon
+        become_daemon(ourHomeDir=options["workdir"])
+
+    if options["pidfile"]:
+        fp = open(options["pidfile"], "w")
+        fp.write("%d\n" % os.getpid())
+        fp.close()
+
+    WSGIServer(WSGIHandler(), **wsgi_opts).run()
+
+
+
+runfastcgi.args = '[various KEY=val options, run `runfcgi help` for help]'
+
 def createcachetable(tablename):
     "Creates the table needed to use the SQL cache backend"
     from django.db import backend, connection, transaction, get_creation_module, models
@@ -1063 +1194 @@
     'inspectdb': inspectdb,
     'install': install,
     'reset': reset,
+    'runfcgi': runfastcgi,
     'runserver': runserver,
     'shell': run_shell,
     'sql': get_sql_create,
@@ -1178 +1310 @@
             except ValueError:
                 addr, port = '', args[1]
         action_mapping[action](addr, port)
+    elif action == 'runfcgi':
+        action_mapping[action](args[1:])
     else:
         from django.db import models
         try:

utils/daemonize.py

@@ +1 @@
+import os
+import sys
+
+if os.name == 'posix':
+
+        def become_daemon(ourHomeDir='.',outLog='/dev/null',errLog='/dev/null'):
+                """
+                Robustly turn us into a UNIX daemon, running in ourHomeDir.
+                Modelled after the original code of this module and some
+                sample code from the net.
+                """
+
+                # first fork
+                try:
+                        if os.fork() > 0:
+                                sys.exit(0)     # kill off parent
+                except OSError, e:
+                        sys.stderr.write("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror))
+                        sys.exit(1)
+                os.setsid()
+                os.chdir(ourHomeDir)
+                os.umask(0)
+                # second fork
+                try:
+                        if os.fork() > 0:
+                                sys.exit(0)
+                except OSError, e:
+                        sys.stderr.write("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror))
+                        sys.exit(1)
+
+                si = open('/dev/null', 'r')
+                so = open(outLog, 'a+', 0)
+                se = open(errLog, 'a+', 0)
+                os.dup2(si.fileno(), sys.stdin.fileno())
+                os.dup2(so.fileno(), sys.stdout.fileno())
+                os.dup2(se.fileno(), sys.stderr.fileno())
+
+else:
+
+        def become_daemon(ourHomeDir='.',outLog=None,errLog=None):
+                """
+                If we are not running under a POSIX system, just simulate
+                the daemon mode by doing redirections and directory changeing
+                """
+
+                os.chdir(ourHomeDir)
+                os.umask(0)
+                sys.stdin.close()
+                sys.stdout.close()
+                sys.stderr.close()
+                if errLog and outLog:
+                        sys.stderr=open (errLog, 'a', 0)
+                        sys.stdout=open (outLog, 'a', 0)
+                elif errLog:
+                        sys.stderr=open (errLog, 'a', 0)
+                        sys.stdout=NullDevice ()
+                elif outLog:
+                        sys.stdout=open (outLog, 'a', 0)
+                        sys.stderr=NullDevice ()
+                else:
+                        sys.stdout = NullDevice()
+                        sys.stderr = NullDevice()
+
+        class NullDevice:
+                """
+                A substitute for stdout and stderr that writes to nowhere.
+                This is a substitute for /dev/null
+                """
+        
+                def write(self, s):
+                        pass