Show Contents Previous Page Next Page
Chapter 1 - Server-Side Programming with Apache
Web Programming Then and Now
In this section...
Introduction Show Contents Go to Top Previous Page Next Page
In the beginning was the web server. Specifically, in the very very beginning was CERN
httpd, a C-language server developed at CERN, the European high-energy physics lab, by Tim Berners-Lee, Ari Luotonen, and Henrik Frystyk Nielsen around 1991. CERN
httpd was designed to serve static web pages. The server listened to the network for Uniform Resource Locator (URL) requests using what would eventually be called the HTTP/0.9 protocol, translated the URLs into file paths, and returned the contents of the files to the waiting client. If you wanted to extend the functionality of the web server--for example, to hook it up to a bibliographic database of scientific papers--you had to modify the server's source code and recompile.
This was neither very flexible nor very easy to do. So early on, CERN
httpd was enhanced to launch external programs to handle certain URL requests. Special URLs, recognized with a complex system of pattern matching and string transformation rules, would invoke a command shell to run an external script or program. The output of the script would then be redirected to the browser, generating a web page on the fly. A simple scheme allowed users to pass argument lists to the script, allowing developers to create keyword search systems and other basic applications.
Meanwhile, Rob McCool, of the National Center for Supercomputing Applications at the University of Illinois, was developing another web server to accompany NCSA's browser product, Mosaic. NCSA
httpd was smaller than CERN
httpd, faster (or so the common wisdom had it), had a host of nifty features, and was easier than the CERN software to configure and install. It quickly gained ground on CERN
httpd, particularly in the United States. Like CERN
httpd, the NCSA product had a facility for generating pages on the fly with external programs but one that differed in detail from CERN
httpd's. Scripts written to work with NCSA
httpd wouldn't work with CERN
httpd and vice versa.
The Birth of CGI Show Contents Go to Top Previous Page Next Page
Fortunately for the world, the CERN and the NCSA groups did not cling tenaciously to "their" standards as certain latter-day software vendors do. Instead, the two groups got together along with other interested parties and worked out a common standard called the Common Gateway Interface.
CGI was intended to be the duct tape of the web--a flexible glue that could quickly and easily bridge between the web protocols and other forms of information technology. And it worked. By following a few easy conventions, CGI scripts can place user-friendly web frontends on top of databases, scientific analysis tools, order entry systems, and games. They can even provide access to older network services, such as gopher, whois, or WAIS. As the web changed from an academic exercise into big business, CGI came along for the ride. Every major server vendor (with a couple of notable exceptions, such as some of the Macintosh server developers) has incorporated the CGI standard into its product. It comes very close to the "write once, run everywhere" development environment that application developers have been seeking for decades.
But CGI is not the highest-performance environment. The Achilles' heel of a CGI script is that every time a web server needs it, the server must set up the CGI environment, read the script into memory, and launch the script. The CGI protocol works well with operating systems that were optimized for fast process startup and many simultaneous processes, such as Unix dialects, provided that the server doesn't become very heavily loaded. However, as load increases, the process creation bottleneck eventually turns formerly snappy scripts into molasses. On operating systems that were designed to run lightweight threads and where full processes are rather heavyweight, such as Windows NT, CGI scripts are a performance disaster.
Another fundamental problem with CGI scripts is that they exit as soon as they finish processing the current request. If the CGI script does some time-consuming operation during startup, such as establishing a database connection or creating complex data structures, the overhead of reestablishing the state each time it's needed is considerable--and a pain to program around.
Server APIs Show Contents Go to Top Previous Page Next Page
An early alternative to the CGI scripting paradigm was the invention of web server APIs (application programming interfaces), mechanisms that the developer can use to extend the functionality of the server itself by linking new modules directly to the server executable. For example, to search a database from within a web page, a developer could write a module that combines calls to web server functions with calls to a relational database library. Add a dash or two of program logic to transform URLs into SQL, and the web server suddenly becomes a fancy database front-end. Server APIs typically provide extensive access to the innards of the server itself, allowing developers to customize how it performs the various phases of the HTTP transaction. Although this might seem like an esoteric feature, it's quite powerful.
The earliest web API that we know of was built into the Plexus web server, written by Tony Sanders of BSDI. Plexus was a 100 percent pure Perl server that did almost everything that web servers of the time were expected to do. Written entirely in Perl Version 4, Plexus allowed the webmaster to extend the server by adding new source files to be compiled and run on an as-needed basis.
APIs invented later include NSAPI, the interface for Netscape servers; ISAPI, the interface used by Microsoft's Internet Information Server and some other Windows-based servers; and of course the Apache web server's API, the only one of the bunch that doesn't have a cute acronym.
Server APIs provide performance and access to the guts of the server's software, giving them programming powers beyond those of mere mortal CGI scripts. Their drawbacks include a steep learning curve and often a certain amount of risk and inconvenience, not to mention limited portability. As an example of the risk, a bug in an API module can crash the whole server. Because of the tight linkage between the server and its API modules, it's never as easy to install and debug a new module as it is to install and debug a new CGI script. On some platforms, you might have to bring the server down to recompile and link it. On other platforms, you have to worry about the details of dynamic loading. However, the biggest problem of server APIs is their limited portability. A server module written for one API is unlikely to work with another vendor's server without extensive revision.
Server-Side Includes Show Contents Go to Top Previous Page Next Page
Another server-side solution uses server-side includes to embed snippets of code inside HTML comments or special-purpose tags. NCSA
httpd was the first to implement server-side includes. More advanced members of this species include Microsoft's Active Server Pages, Allaire Cold Fusion, and PHP, all of which turn HTML into a miniature programming language complete with variables, looping constructs, and database access methods.
Netscape servers recognize HTML pages that have been enhanced with scraps
about later). Embperl, a facility that runs on top of Apache's
module, marries HTML to Perl, as does PerlScript, an ActiveState extension for
Microsoft Internet Information Server.1
The main problem with server-side includes and other HTML extensions is that they're ad hoc. No standards exist for server-side includes, and pages written for one vendor's web server will definitely not run unmodified on another's.
Embedded Interpreters Show Contents Go to Top Previous Page Next Page
To avoid some of the problems of proprietary APIs and server-side includes, several vendors have turned to using embedded high-level interpretive languages in their servers. Embedded interpreters often come with CGI emulation layers, allowing script files to be executed directly by the server without the overhead of invoking separate processes. An embedded interpreter also eliminates the need to make dramatic changes to the server software itself. In many cases an embedded interpreter provides a smooth path for speeding up CGI scripts because little or no source code modification is necessary.
Examples of embedded interpreters include
mod_pyapache, which embeds a Python interpreter. When a Python script is requested, the latency between loading the script and running it is dramatically reduced because the interpreter is already in memory. A similar module exists for the TCL language.
Sun Microsystems' "servlet" API provides a standard way for web servers to run small programs written in the Java programming language. Depending on the implementation, a portion of the Java runtime system may be embedded in the web server or the web server itself may be written in Java. Apache's servlet system uses co-processes rather than an embedded interpreter. These implementations all avoid the overhead of launching a new external process for each request.
Much of this book is about
mod_perl, an Apache module that embeds the Perl interpreter in the server. However, as we shall see,
mod_perl goes well beyond providing an emulation layer for CGI scripts to give programmers complete access to the Apache API.
Script Co-processing Show Contents Go to Top Previous Page Next Page
Another way to avoid the latency of CGI scripts is to keep them loaded and running all the time as a co-process. When the server needs the script to generate a page, it sends it a message and waits for the response.
The first system to use co-processing was the FastCGI protocol, released by Open Market in 1996. Under this system, the web server runs FastCGI scripts as separate processes just like ordinary CGI scripts. However, once launched, these scripts don't immediately exit when they finish processing the initial request. Instead, they go into an infinite loop that awaits new incoming requests, processes them, and goes back to waiting. Things are arranged so that the FastCGI process's input and output streams are redirected to the web server and a CGI-like environment is set up at the beginning of each request.
Existing CGI scripts can be adapted to use FastCGI by making a few, usually
painless, changes to the script source code. Implementations of FastCGI are
available for Apache, as well as Zeus, Netscape, Microsoft IIS, and other servers.
However, FastCGI has so far failed to win wide acceptance in the web development
community, perhaps because of Open Market's retreat from the web server market.
Fortunately, a group of volunteers have picked up the Apache
module and are continuing to support and advance this freeware implementation.
You can find out more about
mod_fastcgi at the www.fastcgi.com
website. Commercial implementations of FastCGI are also available from Fast
Engines, Inc. (www.fastengines.com),
which provides the Netscape and Microsoft IIS versions of FastCGI.
Another co-processing system is an Apache module called Show Contents Go to Top Previous Page Next Page
mod_jserv, which you can find at the project homepage, http://java.apache.org/.
mod_jserv allows Apache to run Java servlets using Sun's servlet API. However, unlike most other servlet systems,
mod_jserv uses something called the "JServ Protocol" to allow the web server to communicate with Java scripts running as separate processes. You can also control these servlets via the Apache Perl API using the
Apache::Servlet module written by Ian Kluft.
Copyright © 1999 by O'Reilly & Associates, Inc.