20.3 Other Server-Side Approaches
A CGI script runs as a new process
each time a client requests it. Process startup time, interpreter
initialization, connection to databases, and script initialization
all add up to measurable overhead. On fast, modern server platforms,
the overhead is bearable for light to moderate loads. On a busy
server, CGI may not scale up well. Web servers support
server-specific ways to reduce overhead, running scripts in processes
that can serve for several hits rather than starting up a new CGI
process per
hit.
Microsoft's
ASP (Active Server Pages) is a server extension leveraging a
lower-level library, ISAPI, and Microsoft's COM
technology. Most ASP pages are coded in the VBScript language, but
ASP is language-independent. As the reptilian connection suggests,
Python and ASP go very well together, as long as Python is installed
with the platform-specific win32all extensions,
specifically ActiveScripting. Many other server
extensions are cross-platform, not tied to specific operating
systems.
The popular content server framework Zope (http://www.zope.org) is a Python application.
If you need advanced content management features, Zope should
definitely be among the solutions you consider. However, Zope is a
large, rich, powerful system, needing a full book of its own to do it
justice. Therefore, I do not cover Zope further in this book.
20.3.1 FastCGI
FastCGI lets you write scripts similar to
CGI scripts, yet use each process to handle multiple hits, either
sequentially or simultaneously in separate threads. FastCGI is
available for Apache and other free web servers, but at the time of
this writing not for Microsoft IIS. See
http://www.fastcgi.com for FastCGI overviews and
details. Go to http://alldunn.com/python/fcgi.py for a pure
Python interface to FastCGI, letting scripts exploit FastCGI if
available and fall back to normal CGI otherwise.
20.3.2 LRWP
Long-Running
Web Processes (LRWP) are currently available only for Xitami (see
http://www.xitami.org). Go to
http://alldunn.com/python/lrwp.py for a pure
Python module (by Robin Dunn, the architect of LRWP) that lets
scripts exploit LRWP if available and fall back to normal CGI
otherwise. LRWP peer processes connect to the web server via sockets.
The server can use any number of peers that offer the same service.
The server uses simple round-robin scheduling among equivalent
available peers. If a request arrives when all peers are busy, the
web server queues the request until a peer is free. This simple,
clean protocol makes it easy to load-balance service requests among
any number of hosts connected to the server's host
by a fast, trusted local area network. Robin Dunn's
article about LRWP, at http://www.imatix.com/html/xitami/index12.htm,
gives architectural details and C and Python examples of LRWP peers.
20.3.3 PyApache and mod_python
Apache's
architecture is modular. Besides CGI and FastCGI, other modules
support Python server-side scripting with Apache. Simple, lightweight
PyApache (http://bel-epa.com/pyapache/) focuses on
letting you use CGI-like scripts with low overhead. mod_python
(http://www.modpython.org)
affords fuller access to Apache internals, including the ability to
write authentication scripts. Both modules support the classic,
widespread Apache 1.3 and the newer Apache 2.0.
20.3.4 Webware
Webware for Python (http://webware.sf.net) is a highly modular
collection of software components for Python server-side web
scripting. You can code Python scripts according to different
programming models, such as CGI scripts with added-value wrappers,
servlets, or Python Server Pages (PSP), and run them under Webware.
Webware, in turn, can interface to your web server in many ways,
including CGI, FastCGI, mod_python, the specialized Apache module
mod_webkit, and special interfaces for Microsoft IIS and AOLServer.
Webware offers you a lot of flexibility in architecting, coding, and
deploying your server-side Python web
scripts.
Among the many ways that Webware offers for you to generate web
pages, one that will often be of interest is templating (i.e.,
automatic insertion of Python-computed values and some control logic
in nearly formed HTML scripts). Webware supports templating via PSP,
but also, with more power and sharper separation between logic and
presentation parts, via the Cheetah package, covered in Chapter 22.
20.3.5 Quixote
Quixote (http://www.mems-exchange.org/software/quixote/)
is another framework for Python web applications that can interface
to your web server via CGI, FastCGI, or mod_python. Quixote defines a
new language, the Python Template Language (PTL), and an import hook
that lets your Python application directly import PTL-coded modules.
Quixote's PTL is nearly the same as Python, but has
a few extras that may be handy in web applications. For example, PTL
keyword template defines functions returning
string results, automatically called to respond to web requests, with
expression statements taken as appending strings to the
function's return value. For example, the PTL code:
template hw( ):
'hello'
'world'
is roughly the same as the following Python code:
def hw( ):
_result = []
_result.append('hello')
_result.append('world')
return ''.join(_result)
20.3.6 Custom Pure Python Servers
In Chapter 19, we saw
that the standard Python library includes modules that implement web
servers. You can subclass BaseHTTPServer and
implement special-purpose web servers with little effort. Such
special-purpose servers are useful in low-volume applications, but
they may not scale up well to handle moderate to high server
loads.
Modules
asyncore and asynchat, also
covered in Chapter 19, exhibit very different
performance characteristics. The event-driven architecture of
asynchat-based applications affords high
scalability and performance, beating applications that use
lower-level languages and traditional architectures (multiprocess or
multithreading).
The Twisted package, also
covered in Chapter 19, has the same performance
advantages as asyncore, and supplies much richer
functionality. With Twisted, you can program a web site at high
levels of abstraction and still obtain superb scalability and
performance.
|