{% set name = "mod-wsgi-7" %}
{% set version = "4.5.7" %}
{% set hash_type = "sha256" %}
{% set hash_value = "5d8e7789f6b2c84696bf58da6e6489246722e13a7ed137f7c9b32f8010017250" %}

package:
  version: '{{ version }}'
  name: '{{ name|lower }}'

source:
  #url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.tar.gz
  url: https://files.pythonhosted.org/packages/28/a7/de0dd1f4fae5b2ace921042071ae8563ce47dac475b332e288bc1d773e8d/mod_wsgi-4.5.7.tar.gz
  '{{ hash_type }}': '{{ hash_value }}'
  fn: '{{ name }}-{{ version }}.tar.gz'

build:
  entry_points:
    - mod_wsgi-express = mod_wsgi.server:main
  number: 0
  script: python setup.py install  --single-version-externally-managed --record=record.txt

requirements:
  run:
    - python
  build:
    - python
    - setuptools

test:
  imports:
    - mod_wsgi
    - mod_wsgi.docs
    - mod_wsgi.images
    - mod_wsgi.server
    - mod_wsgi.server.management
    - mod_wsgi.server.management.commands
  commands:
    - mod_wsgi-express module-location

about:
  dev_url: ''
  description: "Overview\n--------\n\nThe mod_wsgi package provides an Apache module that implements a WSGI\ncompliant interface for hosting Python based web applications on top of the\nApache web server.\n\
    \nInstallation of mod_wsgi from source code can be performed in one of two\nways.\n\nThe first way of installing mod_wsgi is the traditional way that has been\nused by many software packages. This is\
    \ where it is installed as a module\ndirectly into your Apache installation using the commands ``configure``,\n``make`` and ``make install``, a method sometimes referred to by the\nacyronym CMMI.\n\n\
    The second and newest way of installing mod_wsgi is to install it as a\nPython package into your Python installation using the Python ``pip\ninstall`` command.\n\nThis newer way of installing mod_wsgi\
    \ will compile not only the Apache\nmodule for mod_wsgi, but will also install a Python module and admin script\nfor starting up a standalone instance of Apache directly from the command\nline with\
    \ an auto generated configuration.\n\nThis later mechanism for installing mod_wsgi using Python ``pip`` is a much\nsimpler way of getting starting with hosting your Python web application.\nIn particular,\
    \ the new installation method makes it very easy to use\nApache/mod_wsgi in a development environment without the need to perform\nany Apache configuration yourself.\n\nThe Apache module for mod_wsgi\
    \ created when using the ``pip install``\nmethod can still be used with the main Apache installation, via manual\nconfiguration if necessary.\n\nOn some platforms, this latter method is actually the\
    \ only option supported\nwhen using the operating system supplied Apache installation. For example,\nin MacOS X Sierra, Apple has completely broken the ability to install third\nparty Apache modules\
    \ using the ``apxs`` tool normally used for this task.\nHistory suggests that Apple will never fix the problem as they have broken\nthings in the past in other ways and workarounds were required as\
    \ they\nnever fixed those problems either. This time there is no easy workaround as\nthey no longer supply certain tools which are required to perform the\ninstallation.\n\nSystem Requirements\n-------------------\n\
    \nWith either installation method for mod_wsgi, you must have Apache\ninstalled. This must be a complete Apache installation. It is not enough to\nhave only the runtime packages for Apache installed.\
    \ You must have the\ncorresponding development package for Apache installed, which contains the\nApache header files, as these are required to be able compile and install\nthird party Apache modules.\n\
    \nSimilarly with Python, you must have a complete Python installation which\nincludes the corresponding development package, which contains the header\nfiles for the Python library.\n\nIf you are running\
    \ Debian or Ubuntu Linux with Apache 2.2 system packages,\nand were using the Apache prefork MPM you would need both:\n\n* apache2-mpm-prefork\n* apache2-prefork-dev\n\nIf instead you were using the\
    \ Apache worker MPM, you would need both:\n\n* apache2-mpm-worker\n* apache2-threaded-dev\n\nIf you are running Debian or Ubuntu Linux with Apache 2.4 system packages,\nregardless of which Apache MPM\
    \ is being used, you would need both:\n\n* apache2\n* apache2-dev\n\nIf you are running RHEL, CentOS or Fedora, you would need both:\n\n* httpd\n* httpd-devel\n\nIf you are using the Software Collections\
    \ Library (SCL) packages with\nRHEL, CentOS or Fedora, you would need:\n\n* httpd24\n* httpd24-httpd-devel\n\nIf you are running MacOS X, you will need to have the Xcode command line\ntools installed.\
    \ These can be installed by running ``xcode-select --install``.\n\nInstallation into Apache\n------------------------\n\nFor installation directly into your Apache installation using the CMMI\nmethod,\
    \ see the full documentation at:\n\n* http://www.modwsgi.org/\n\nAlternatively, use the following instructions to install mod_wsgi into your\nPython installation and then either copy the mod_wsgi module\
    \ into your\nApache installation, or configure Apache to use the mod_wsgi module from\nthe Python installation.\n\nWhen using this approach, you will still need to manually configure Apache\nto have\
    \ mod_wsgi loaded into Apache, and for it to know about your WSGI\napplication.\n\nInstallation into Python\n------------------------\n\nTo install the mod_wsgi directly into your Python installation,\
    \ from within\nthe source directory of the mod_wsgi package you can run::\n\n    python setup.py install\n\nThis will compile mod_wsgi and install the resulting package into your\nPython installation.\n\
    \nIf wishing to install an official release direct from the Python Package\nIndex (PyPi), you can instead run::\n\n    pip install mod_wsgi\n\nIf you wish to use a version of Apache which is installed\
    \ into a non\nstandard location, you can set and export the ``APXS`` environment variable\nto the location of the Apache ``apxs`` script for your Apache installation\nbefore performing the installation.\n\
    \nNote that nothing will be copied into your Apache installation at this\npoint. As a result, you do not need to run this as the root user unless\ninstalling it into a site wide Python installation\
    \ rather than a Python\nvirtual environment. It is recommended you always use Python virtual\nenvironments and never install any Python package direct into the system\nPython installation.\n\nTo verify\
    \ that the installation was successful, run the ``mod_wsgi-express``\nscript with the ``start-server`` command::\n\n    mod_wsgi-express start-server\n\nThis will start up Apache/mod_wsgi on port 8000.\
    \ You can then verify that\nthe installation worked by pointing your browser at::\n\n    http://localhost:8000/\n\nWhen started in this way, the Apache web server will stay in the\nforeground. To stop\
    \ the Apache server, use CTRL-C.\n\nFor a simple WSGI application contained in a WSGI script file called\n``wsgi.py``, in the current directory, you can now run::\n\n    mod_wsgi-express start-server\
    \ wsgi.py\n\nThis instance of the Apache web server will be completely independent of,\nand will not interfere with any existing instance of Apache you may have\nrunning on port 80.\n\nIf you already\
    \ have another web server running on port 8000, you can\noverride the port to be used using the ``--port`` option::\n\n    mod_wsgi-express start-server wsgi.py --port 8080\n\nFor a complete list of\
    \ options you can run::\n\n    mod_wsgi-express start-server --help\n\nFor further information related to using ``mod_wsgi-express`` see the main\nmod_wsgi documentation.\n\nNon standard Apache installations\n\
    ---------------------------------\n\nMany Linux distributions have a tendency to screw around with the standard\nApache Software Foundation layout for installation of Apache. This can\ninclude renaming\
    \ the Apache ``httpd`` executable to something else, and in\naddition to potentially renaming it, replacing the original binary with a\nshell script which performs additional actions which can only\
    \ be performed\nas the ``root`` user.\n\nIn the case of the ``httpd`` executable simply being renamed, the\nexecutable will obviously not be found and ``mod_wsgi-express`` will fail\nto start at all.\n\
    \nIn this case you should work out what the ``httpd`` executable was renamed\nto and use the ``--httpd-executable`` option to specify its real location.\n\nFor example, if ``httpd`` was renamed to ``apache2``,\
    \ you might need to use::\n\n    mod_wsgi-express start-server wsgi.py --httpd-executable=/usr/sbin/apache2\n\nIn the case of the ``httpd`` executable being replaced with a shell script\nwhich performs\
    \ additional actions before then executing the original\n``httpd`` executable, and the shell script is failing in some way, you will\nneed to use the location of the original ``httpd`` executable the\
    \ shell\nscript is in turn executing.\n\nRunning mod_wsgi-express as root\n--------------------------------\n\nThe primary intention of ``mod_wsgi-express`` is to make it easier for\nusers to run up\
    \ Apache on non privileged ports, especially during the\ndevelopment of a Python web application. If you want to be able to run\nApache using ``mod_wsgi-express`` on a privileged port such as the standard\n\
    port 80 used by HTTP servers, then you will need to run\n``mod_wsgi-express`` as root. In doing this, you will need to perform\nadditional steps.\n\nThe first thing you must do is supply the ``--user``\
    \ and ``--group``\noptions to say what user and group your Python web application should run\nas. Most Linux distributions will pre define a special user for Apache to\nrun as, so you can use that.\
    \ Alternatively you can use any other special\nuser account you have created for running the Python web application::\n\n    mod_wsgi-express start-server wsgi.py --port=80 \\\n        --user www-data\
    \ --group www-data\n\nThis approach to running ``mod_wsgi-express`` will be fine so long as you\nare using a process supervisor which expects the process being run to remain\nin the foreground and not\
    \ daemonize.\n\nIf however you are directly integrating into the system init scripts where\nseparate start and stop commands are expected, with the executing process\nexpected to be daemonized, then\
    \ a different process is required to setup\n``mod_wsgi-express``.\n\nIn this case, instead of simply using the ``start-server`` command to\n``mod_wsgi-express`` you should use ``setup-server``::\n\n\
    \    mod_wsgi-express setup-server wsgi.py --port=80 \\\n        --user www-data --group www-data \\\n        --server-root=/etc/mod_wsgi-express-80\n\nIn running this command, it will not actually\
    \ startup Apache. All it will do\nis create the set of configuration files and the startup script to be run.\n\nSo that these are not created in the default location of a directory under\n``/tmp``,\
    \ you should use the ``--server-root`` option to specify where they\nshould be placed.\n\nHaving created the configuration and startup script, to start the Apache\ninstance you can now run::\n\n   \
    \ /etc/mod_wsgi-express-80/apachectl start\n\nTo subsequently stop the Apache instance you can run::\n\n    /etc/mod_wsgi-express-80/apachectl stop\n\nYou can also restart the Apache instance as necessary\
    \ using::\n\n    /etc/mod_wsgi-express-80/apachectl restart\n\nUsing this approach, the original options you supplied to ``setup-server``\nwill be cached with the same configuration used each time.\
    \ If you need to\nupdate the set of options, run ``setup-server`` again with the new set of\noptions.\n\nNote that even taking all these steps, it is possible that running up\nApache as ``root`` using\
    \ ``mod_wsgi-express`` may fail on systems where\nSELinux extensions are enabled. This is because the SELinux profile may not\nmatch what is being expected for the way that Apache is being started,\
    \ or\nalternatively, the locations that Apache has been specified as being\nallowed to access, don't match where the directory specified using the\n``--server-root`` directory was placed. You may therefore\
    \ need to configure\nSELinux or move the directory used with ``--server-root`` to an allowed\nlocation.\n\nUsing mod_wsgi-express with Django\n----------------------------------\n\nTo use ``mod_wsgi-express``\
    \ with Django, after having installed the\nmod_wsgi package into your Python installation, edit your Django settings\nmodule and add ``mod_wsgi.server`` to the list of installed apps.\n\n::\n\n    INSTALLED_APPS\
    \ = (\n        'django.contrib.admin',\n        'django.contrib.auth',\n        'django.contrib.contenttypes',\n        'django.contrib.sessions',\n        'django.contrib.messages',\n        'django.contrib.staticfiles',\n\
    \        'mod_wsgi.server',\n    )\n\nTo prepare for running ``mod_wsgi-express``, ensure that you first collect\nup any Django static file assets into the directory specified for them in\nthe Django\
    \ settings file::\n\n    python manage.py collectstatic\n\nYou can now run the Apache server with mod_wsgi hosting your Django\napplication by running::\n\n    python manage.py runmodwsgi\n\nIf working\
    \ in a development environment and you would like to have any code\nchanges automatically reloaded, then you can use the ``--reload-on-changes``\noption.\n\n::\n\n    python manage.py runmodwsgi --reload-on-changes\n\
    \nIf wanting to have Apache started as root in order to listen on port 80,\ninstead of using ``mod_wsgi-express setup-server`` as described above,\nuse the ``--setup-only`` option to the ``runmodwsgi``\
    \ management command.\n\n::\n\n    python manage.py runmodwsgi --setup-only --port=80 \\\n        --user www-data --group www-data \\\n        --server-root=/etc/mod_wsgi-express-80\n \nThis will setup\
    \ all the required files and you can use ``apachectl`` to\nstart and stop the Apache instance as explained previously.\n\nConnecting into Apache installation\n-----------------------------------\n\n\
    If you want to use mod_wsgi in combination with your system Apache\ninstallation, the CMMI method for installing mod_wsgi would normally be\nused. If you are on MacOS X Sierra that is no longer possible.\
    \ Even prior\nto MacOS X Sierra, the System Integrity Protection (SIP) system of MacOS X,\nprevented installing the mod_wsgi module into the Apache modules\ndirectory.\n\nThe CMMI installation method\
    \ also involves a bit more work as you need to\nseparately download the mod_wsgi source code, run the ``configure`` tool\nand then run ``make`` and ``make install``.\n\nThe alternative to using the\
    \ CMMI installation method is to use the Apache\nmod_wsgi module created by running ``pip install``. This can be directly\nreferenced from the Apache configuration, or copied into the Apache modules\n\
    directory.\n\nTo use the Apache mod_wsgi module from where ``pip install`` placed it,\nrun the command ``mod_wsgi-express module-config``. This will output\nsomething like::\n\n    LoadModule wsgi_module\
    \ /usr/local/lib/python2.7/site-packages/mod_wsgi/server/mod_wsgi-py27.so\n    WSGIPythonHome /usr/local/lib\n\nThese are the directives needed to configure Apache to load the mod_wsgi\nmodule and tell\
    \ mod_wsgi where the Python installation directory or virtual\nenvironment was located.\n\nThis would be placed in the Apache ``httpd.conf`` file, or if the Linux\ndistribution separates out module\
    \ configuration into a ``mods-available``\ndirectory, in the ``wsgi.load`` file within the ``mods-available``\ndirectory. In the latter case where a ``mods-available`` directory is used,\nthe module\
    \ would then be enabled by running ``a2enmod wsgi`` as ``root``.\nIf necessary Apache can then be restarted to verify the module is loading\ncorrectly. You can then configure Apache as necessary for\
    \ your specific\nWSGI application.\n\nNote that because in this scenario the mod_wsgi module for Apache could be\nlocated in a Python virtual environment, if you destroy the Python virtual\nenvironment\
    \ the module will also be deleted. In that case you would need to\nensure you recreated the Python virtual environment and reinstalled the\nmod_wsgi package using ``pip``, or take out the mod_wsgi configuration\
    \ from\nApache before restarting Apache or it will fail to startup.\n\nInstead of referencing the mod_wsgi module from the Python installation,\nyou can instead copy the mod_wsgi module into the Apache\
    \ installation. To\ndo that, run the ``mod_wsgi-express install-module`` command, running it as\n``root`` if necessary. This will output something like::\n\n    LoadModule wsgi_module modules/mod_wsgi-py27.so\n\
    \    WSGIPythonHome /usr/local/lib\n\nThis is similar to above except that the mod_wsgi module was copied to the\nApache modules directory first and the ``LoadModule`` directive references\nit from\
    \ that location. You should take these lines and configure Apache in\nthe same way as described above. Do note that copying the module like this\nwill not work on recent versions of MacOS X due to the\
    \ SIP feature of MacOS X."
  license: Apache Software License
  license_family: APACHE
  summary: Installer for Apache/mod_wsgi.
  home: http://www.modwsgi.org/
  license_file: ''
  doc_url: ''

extra:
  recipe-maintainers: ''