Credit: Jeff Bauer
You want a simple CGI program to use as a starting point for your own CGI programming or to test if your setup is functioning properly.
The cgi
module is normally used in Python CGI programming, but here we use
only its escape function to ensure that the value of an
environment variable doesn’t accidentally look to
the browser as HTML markup. We do all of the real work ourselves:
#!/usr/local/bin/python
print "Content-type: text/html"
print
print "<html><head><title>Situation snapshot</title></head><body><pre>"
import sys
sys.stderr = sys.stdout
import os
from cgi import escape
print "<strong>Python %s</strong>" % sys.version
keys = os.environ.keys( )
keys.sort( )
for k in keys:
print "%s\t%s" % (escape(k), escape(os.environ[k]))
print "</pre></body></html>"The Common Gateway Interface (CGI) is a protocol that specifies how a web server runs a separate program (often known as a CGI script) that generates a web page dynamically. The protocol specifies how the server provides input and environment data to the script and how the script generates output in return. You can use any language to write your CGI scripts, and Python is well-suited for the task.
This recipe is a simple CGI program that displays the current version
of Python and the environment values. CGI programmers should always
have some simple code handy to drop into their
cgi-bin directories. You should run this script
before wasting time slogging through your Apache configuration files
(or whatever other web server you want to use for CGI work). Of
course, cgi.test does all this and more, but it
may, in fact, do too much. It does so much, and so much is hidden
inside cgi’s innards, that
it’s hard to tweak it to reproduce whatever specific
problems you may be encountering in true scripts. Tweaking the
program in this recipe, on the other hand, is very easy, since
it’s such a simple program, and all the parts are
exposed.
Besides, this little script is already quite instructive in its own
way. The starting line,
#!/usr/local/bin/python,
must give the absolute path to the Python interpreter with which you
want to run your CGI scripts, so you may need to edit it accordingly.
A popular solution for non-CGI scripts is to have a first line (the
so-called "shebang line”) that looks
something like this:
#!/usr/bin/env python
However, this puts you at the mercy of the PATH
environment setting, since it runs the first program named
python it finds on the PATH,
and that probably is not what you want under CGI, where you
don’t fully control the environment. Incidentally,
many web servers implement the shebang line even when you run them
under non-Unix systems, so that, for CGI use specifically,
it’s not unusual to see Python scripts on Windows
start with a first line such as:
#!c:/python22/python.exe
Another issue you may be contemplating is why the
import statements are not right at the start
of the script, as is the usual Python style, but are preceded by a
few print statements. The reason is that
import could fail if the Python installation is
terribly misconfigured. In case of failure, Python will emit
diagnostics to standard error (which is typically directed to your
web server logs, depending, of course, on how you set up and
configured your web server), and nothing will go to standard output.
The CGI standard demands that all output be on standard output, so,
we first ensure that a minimal quantity of output will display a
result to a visiting browser. Then, assuming that import sys succeeds (if it fails, the whole installation and
configuration is so badly broken that there’s very
little you can do about it!), you immediately make the following
assignment:
sys.stderr = sys.stdout
This ensures that error output will also
go to standard output, and you’ll have a chance to
see it in the visiting browser. You can perform other
import operations or do further work in the script
only when this is done. In Python 2.2, getting useful tracebacks for
errors in CGI scripts is much simpler. Simply add the following at
the start of your script:
import cgitb; cgitb.enable()
and the new standard module cgitb takes care of
the rest
Just about all known browsers let you get away with skipping most of the HTML tags that this script outputs, but why skimp on correctness, relying on the browser to patch your holes? It costs little to emit correct HMTL, so you should get into the habit of doing things right, when the cost is so modest.
Documentation of the standard library module cgi
in the Library Reference; a basic introduction
to the CGI protocol is available at http://hoohoo.ncsa.uiuc.edu/cgi/overview.html.
Get Python Cookbook now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.
