Removed FastCGI support per deprecation timeline; refs #20766.

USE_X_FORWARDED_HOST = False

# The Python dotted path to the WSGI application that Django's internal servers

# (runserver, runfcgi) will use. If `None`, the return value of

# The Python dotted path to the WSGI application that Django's internal server

# (runserver) will use. If `None`, the return value of

# 'django.core.wsgi.get_wsgi_application' is used, thus preserving the same

# behavior as previous versions of Django. Otherwise this should point to an

# actual WSGI application object.

        # special case: the 'help' subcommand has no options

        elif cwords[0] in subcommands and cwords[0] != 'help':

            subcommand_cls = self.fetch_command(cwords[0])

            # special case: 'runfcgi' stores additional options as

            # 'key=value' pairs

            if cwords[0] == 'runfcgi':

                from django.core.servers.fastcgi import FASTCGI_OPTIONS

                options.extend((k, 1) for k in FASTCGI_OPTIONS)

            # special case: add the names of installed apps to options

            elif cwords[0] in ('dumpdata', 'sql', 'sqlall', 'sqlclear',

            if cwords[0] in ('dumpdata', 'sql', 'sqlall', 'sqlclear',

                    'sqlcustom', 'sqlindexes', 'sqlmigrate', 'sqlsequencereset', 'test'):

                try:

                    app_configs = apps.get_app_configs()

import argparse

import warnings

from django.core.management.base import BaseCommand

from django.utils.deprecation import RemovedInDjango19Warning

class Command(BaseCommand):

    help = "Runs this project as a FastCGI application. Requires flup."

    def add_arguments(self, parser):

        parser.add_argument('args', nargs=argparse.REMAINDER,

            help='Various KEY=val options.')

    def handle(self, *args, **options):

        warnings.warn(

            "FastCGI support has been deprecated and will be removed in Django 1.9.",

            RemovedInDjango19Warning)

        from django.conf import settings

        from django.utils import translation

        # Activate the current language, because it won't get activated later.

        try:

            translation.activate(settings.LANGUAGE_CODE)

        except AttributeError:

            pass

        from django.core.servers.fastcgi import runfastcgi

        runfastcgi(args)

    def usage(self, subcommand):

        from django.core.servers.fastcgi import FASTCGI_HELP

        return FASTCGI_HELP

    this will be the ``application`` object in ``projectname/wsgi.py``.

    This function, and the ``WSGI_APPLICATION`` setting itself, are only useful

    for Django's internal servers (runserver, runfcgi); external WSGI servers

    should just be configured to point to the correct application object

    directly.

    for Django's internal server (runserver); external WSGI servers should just

    be configured to point to the correct application object directly.

    If settings.WSGI_APPLICATION is not set (is ``None``), we just return

    whatever ``django.core.wsgi.get_wsgi_application`` returns.

    """

    from django.conf import settings

    app_path = getattr(settings, 'WSGI_APPLICATION')

"""

FastCGI (or SCGI, or AJP1.3 ...) server that implements the WSGI protocol.

Uses the flup python package: http://www.saddi.com/software/flup/

This is an adaptation of the flup package to add FastCGI server support

to run Django apps from Web servers that support the FastCGI protocol.

This module can be run standalone or from the django-admin / manage.py

scripts using the "runfcgi" directive.

Run with the extra option "help" for a list of additional options you can

pass to this server.

"""

import importlib

import os

import sys

__version__ = "0.1"

__all__ = ["runfastcgi"]

FASTCGI_OPTIONS = {

    'protocol': 'fcgi',

    'host': None,

    'port': None,

    'socket': None,

    'method': 'fork',

    'daemonize': None,

    'workdir': '/',

    'pidfile': None,

    'maxspare': 5,

    'minspare': 2,

    'maxchildren': 50,

    'maxrequests': 0,

    'debug': None,

    'outlog': None,

    'errlog': None,

    'umask': None,

}

FASTCGI_HELP = r"""

  Run this project as a fastcgi (or some other protocol supported

  by flup) application. To do this, the flup package from

  http://www.saddi.com/software/flup/ is required.

   runfcgi [options] [fcgi settings]

Optional Fcgi settings: (setting=value)

  protocol=PROTOCOL    fcgi, scgi, ajp, ... (default %(protocol)s)

  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 %(method)s).

  maxrequests=NUMBER   number of requests a child handles before it is

                       killed and a new child is forked (0 = no limit).

  maxspare=NUMBER      max number of spare processes / threads (default %(maxspare)s).

  minspare=NUMBER      min number of spare processes / threads (default %(minspare)s).

  maxchildren=NUMBER   hard limit number of processes / threads (default %(maxchildren)s).

  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 (default %(workdir)s).

  debug=BOOL           set to true to enable flup tracebacks.

  outlog=FILE          write stdout to this file.

  errlog=FILE          write stderr to this file.

  umask=UMASK          umask to use when daemonizing, in octal notation (default 022).

Examples:

  Run a "standard" fastcgi process on a file-descriptor

  (for Web servers which spawn your processes for you)

    $ manage.py runfcgi method=threaded

  Run a scgi server on a TCP host/port

    $ manage.py runfcgi protocol=scgi 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

""" % FASTCGI_OPTIONS

def fastcgi_help(message=None):

    print(FASTCGI_HELP)

    if message:

        print(message)

    return False

def runfastcgi(argset=[], **kwargs):

    options = FASTCGI_OPTIONS.copy()

    options.update(kwargs)

    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  # NOQA

    except ImportError as e:

        sys.stderr.write("ERROR: %s\n" % e)

        sys.stderr.write("  Unable to load the flup package.  In order to run django\n")

        sys.stderr.write("  as a FastCGI application, you will need to get flup from\n")

        sys.stderr.write("  http://www.saddi.com/software/flup/   If you've already\n")

        sys.stderr.write("  installed flup, then make sure you have it in your PYTHONPATH.\n")

        return False

    flup_module = 'server.' + options['protocol']

    if options['method'] in ('prefork', 'fork'):

        wsgi_opts = {

            'maxSpare': int(options["maxspare"]),

            'minSpare': int(options["minspare"]),

            'maxChildren': int(options["maxchildren"]),

            'maxRequests': int(options["maxrequests"]),

        }

        flup_module += '_fork'

    elif options['method'] in ('thread', 'threaded'):

        wsgi_opts = {

            'maxSpare': int(options["maxspare"]),

            'minSpare': int(options["minspare"]),

            'maxThreads': int(options["maxchildren"]),

        }

    else:

        return fastcgi_help("ERROR: Implementation must be one of prefork or "

                            "thread.")

    wsgi_opts['debug'] = options['debug'] is not None

    try:

        module = importlib.import_module('.%s' % flup_module, 'flup')

        WSGIServer = module.WSGIServer

    except Exception:

        print("Can't import flup." + flup_module)

        return False

    # Prep up and go

    from django.core.servers.basehttp import get_internal_wsgi_application

    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're running on a socket/named pipe.

        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.")

    daemon_kwargs = {}

    if options['outlog']:

        daemon_kwargs['out_log'] = options['outlog']

    if options['errlog']:

        daemon_kwargs['err_log'] = options['errlog']

    if options['umask']:

        daemon_kwargs['umask'] = int(options['umask'], 8)

    if daemonize:

        from django.utils.daemonize import become_daemon

        become_daemon(our_home_dir=options["workdir"], **daemon_kwargs)

    if options["pidfile"]:

        with open(options["pidfile"], "w") as fp:

            fp.write("%d\n" % os.getpid())

    WSGIServer(get_internal_wsgi_application(), **wsgi_opts).run()

if __name__ == '__main__':

    runfastcgi(sys.argv[1:])