Python

Webware of course requires Python. It has been tested with Python version ranging from 2.0 to 2.6. Python 1.5.2 isn't supported anymore. If you get an error message about the version, you're probably unwittingly running the wrong version of Python. Change the AppServer or AppServer.bat scripts, giving the full path to the correct Python interpreter.

Your installation of Python must be multi-threaded. It's not entirely uncommon for third party web host providers to leave this disabled in Python because they don't expect that it's needed or for compatibility with some software. If your Python installation is not multi-threaded you will have to reinstall it. If you're using a third party host provider in this situation, you may be able to install it yourself into your home directory via a telnet or ssh account. See the Python site for instructions.

To determine if threading is enabled, start the Python interpreter from the command line and enter import thread. If you don't get an exception, all is well.

Web Server

Webware's built-in web server is adequate for development and casual use. Beyond that, you will want to use Webware in concert with another web server.

Any web server that supports CGI should be usable with Webware. Apache is the best supported platform, both on Posix and Windows systems. There is some experimental support for Xitami. For all other web servers (IIS included) you should expect to use CGI to interface with the AppServer.

> cscript adsutil.vbs SET W3SVC/1/AllowPathInfoForScriptMappings 1

Webware Version

Unless you just downloaded Webware (and therefore WebKit), you should check to see if you have the latest version. This is:

Webware for Python

You can check for the latest version at http://www.webwareforpython.org.

If you're feeling adventurous, you can get the latest in-development source code from the public repository. Instructions are located at the Webware SVN page. You can find more information about SVN in general in the Subversion Book. The SVN version of Webware is generally fairly stable.

Operating Systems

WebKit actively supports Posix (Linux, BSD, Mac OS X, Solaris, etc) and Windows (95/98/NT/2K/XP), and their various flavors.

Note that you don't have to develop and deploy on the same platform. One of the WebKit developers develops everything on Windows 98 2nd edition and deploys his web sites on BSD. Some of the web server setup is different, but in most cases the application itself will require no porting (unless you specifically use non-portable Python code in your application).

What follows are some OS specific notes:

Posix/Unix:

Nothing special to report. Both Linux and BSD have been used with WebKit.

Windows 9x:

Although a lot of the development of both WebKit and various web sites that use it has been done on Windows 9x, we don't recommend that you use this operating system to actually serve your users. Unix and NT are generally more robust and secure and therefore, more appropriate for deployment.

Windows:

Some Windows users are surprised that URLs passed to WebKit are case sensitive. While it's true that the various Windows file systems are case insensitive, the data structures that WebKit uses internally are not.

When editing path names in configuration files, keep in mind that you are editing a Python dictionary populated with Python strings. Therefore your paths must either use double backslashes (\) (since the backslash is a special character), use forward slashes or use "r-strings". An example of a bad string is 'C:\All\Web\'. Good examples include:

• '/All/Web'
• 'C:/All/Web'
• 'C:\\All\\Web'
• 'C:\All\Web'

It's generally recommended to simply use forward slashes (/) for all your file paths.

Permissions

Webware runs as whatever user you run the AppServer as. So, while Apache might be running as nobody, if you start the AppServer as root then your application will be run as root. You may wish to set up another user specifically for running the AppServer. On Unix:

$ adduser --no-create-home --system webkit
$ cd path/to/Webware/WebKit
$ sudo -u webkit ./AppServer

Whatever user you run the AppServer as, there are some directories under Webware/WebKit/ that must be writable by that user:

• Cache
• ErrorMsgs
• Logs
• Sessions

The easiest way to do this is to make these directories writeable by all (on Unix, that would be cd Webware/WebKit; chmod -R a+rwX Cache ErrorMsgs Logs Sessions).

You may wish to set it up this way at first, and review the permissions and create a new user later.

Adapters

A WebKit adapter takes an HTTP request from a web server and, as quickly as possible, packs it up and ships it to the app server which subsequently sends the response back to the adapter for delivery to the web server and ultimately the web client. More concisely, an adapter is the go-between of the web server and the app server.

There are several adapters for Webware. However, it is highly recommended that you either use wkcgi or mod_webkit. Mod_webkit is the fastest adapter, but requires you to use Apache and usually to have root access to the computer. The wkcgi program uses CGI, and so is easy to install. Because it's small and written in C, wkcgi is still very fast.

All the adapters:

• wkcgi, C-based CGI script
• mod_webkit (fastest!)
• AOLServer
• LRWP (Xitami)

These adapters are not really recommended:

• Python CGI Adapter
• FastCGI
• mod_python
• mod_snake
• ISAPI (alpha, for IIS)
• OneShot (unusual to use, sometimes buggy)

SCGI-based Adapters

Instead of using the standard WebKit adapter, you can also use any SCGI adapter such as mod_scgi (not part of Webware for Python). You can activate the SCGI connector, i.e. an WebKit app server listener for SCGI connections, with the AppServer.config setting EnableSCGI. The port can be specified with the setting SCGIPort and will be 8084 by default (SCGI often uses port 4000 or 9999, you may want to change that). Support for SCGI has been built into Webware only recently and may not be so sophisticated as the standard WebKit adapter.

CGI-based Adapters

CGI-based adapters are the easiest to set up, and outside of Apache, Xitami, and AOLServer they are pretty much the only option.

Though these are CGI-based adapters, WebKit still runs as a persistent program with the AppServer. The CGI adapter is a program executed by the web server, which then contacts the AppServer and returns the response to the web server. Then the adapter quits, to be started again for another request. This starting up and stopping is what makes CGI slow. Because the adapter is small, this should still be faster than a all-CGI application, because most of the work is done in the persistent AppServer.

$ cd /path/to/Webware/WebKit/Adapters/wkcgi
$ make

Host = localhost
AdapterPort = 8086
MaxConnectAttempts = 10
ConnectRetryDelay = 1

$ cd /path/to/Webware/WebKit/Adapters/mod_webkit2
$ make
$ make install

LoadModule webkit_module modules/mod_webkit.so

<Location /WK>
    WKServer localhost 8086
    SetHandler webkit-handler
</Location>

AddHandler psp-handler .psp

PassHeader Accept-Language

lang = self.request().environ().get('Accept-Language')

Renaming Adapters

Adapters such as WebKit.cgi and OneShot.cgi do not rely on their name. Consequently, when you deploy your web site, you can rename the adapter to something like serve.cgi. This allows you to switch adapters later without affecting the URLs and therefore the bookmarks of your users (provided you're still using some form of CGI adapter). mod_rewrite also offers several possibilities for changing names, redirecting the root of a site to a specific context, or other URL manipulations. Mod_rewrite is extremely general.

Adapter Problems (not CGI)

There is one gotcha in setting up the adapters that don't rely on CGI. For mod_webkit, ModPython and ModSnake, the name that you give to the adapter location in your Apache configuration file must not actually exist in your Apache document root. Also, you may not have a file or directory in your document root with the same name as one of WebKit's contexts. So, you can't have a directory named Examples in your document root.

Sessions

WebKit provides a Session utility class for storing data on the server side that relates to an individual user's session with your site. The SessionStore setting determines where the data is stored and can currently be set to Dynamic or File.

Storing to the Dynamic session store is the fastest solution and is the default. This session storage method keeps the most recently used sessions in memory, and moves older sessions to disk periodocally. All sessions will be moved to disk when the server is stopped. This storage mechanism works with both the persistant, long running AppServers and OneShot. There are two settings in Application.config relating to this Session store. MaxDynamicMemorySessions specifies the maximum number of sessions that can be in memory at any one time. DynamicSessionTimeout specifies after what period of time sessions will be moved from memory to file. (Note: this setting is unrelated to the SessionTimeout setting below. Sessions which are moved to disk by the Dynamic Session store are not deleted).

Storing to files is provided mainly in support of the OneShot adapter. It may also prove useful in the future in support of load balancing. In this scenario, each individual session is stored in its own file, loaded for every request and saved when delivering the corresponding response.

All on-disk session information is located in WebKit/Sessions.

Also, the SessionTimeout setting lets you set the number of minutes of inactivity before a user's session becomes invalid and is deleted. The default is 60. The Session Timeout value can also be changed dynamically on a per session basis.

Activity Log

Three options let you control:

• Whether or not to log activity (LogActivity, defaults to 0, i.e. off)
• The name of the file to store the log (ActivityLogFilename, defaults to Logs/Activity.csv)
• The fields to store in the log (ActivityLogColumns) </ul>

See Configuration in the User's Guide for more information.

E-mail Errors

EmailErrors, ErrorEmailServer and ErrorEmailHeaders let you configure the app server so that uncaught exceptions land in your mailbox in real time. You should definitely set these options when deploying a web site.

See Configuration in the User's Guide for more information.

Contexts

WebKit divides the world into contexts, each of which is a directory with its own files and servlets. WebKit will only serve files out of its list of known contexts.

Some of the contexts you will find out of the box are Examples, Documentation and Admin. When viewing either an example or admin page, you will see a sidebar that links to all the contexts.

Another way to look at contexts is a means for "directory partitioning". If you have two distinct web applications (for example, PythonTutor and DayTrader), you will likely put each of these in their own context. In this configuration, both web applications would be served by the same appserver instance. Note that there may be also reasons to run multiple appserver instances for serving your web applications. For instance, this would allow you to start and stop them independently, run them under different users to give them different permissions, or partition resources like number of threads individually among the web applications.

Instead of adding your own contexts you may wish to use MakeAppWorkDir, which will partition your application from the Webware installation.

To add a new context, add to the Contexts dictionary of Application.config. The key is the name of the context as it appears in the URL and the value is the path (absolute or relative to the WebKit directory). Often the name of the context and the name of the directory will be the same:

'DayTrader': '/All/Web/Apps/DayTrader',

The URL to access DayTrader would then be something like: http://localhost/WebKit.cgi/DayTrader/

The special name default is reserved to specify what context is served when none is specified (as in http://localhost/WebKit.cgi/). Upon installation, this is the Examples context, which is convenient during development since it provides links to all the other contexts.

Note that a context can contain an __init__.py which will be executed when the context is loaded at app server startup. You can put any kind of initialization code you deem appropriate there.

Creating a Working Directory

You can create a working directory for your applications that is separate from the Webware installation. To do this you will use the script bin/MakeAppWorkDir.py. You should run it like:

$ python Webware/bin/MakeAppWorkDir.py WorkDir

This will create a directory WorkDir that will contain a directory structure for your application. Name if after your application, place it where it is convenient for you -- it doesn't need to be located close to the Webware installation.

You have a couple of options available, e.g. for chosing the name and location of the default context or creating additional library directories that will be added to the Python seach path. You can see all of these options if you run bin/MakeAppWorkDir.py without any parameters.

When you list the created directory, you will see something like this:

AppServer*  Configs/       ErrorMsgs/  Lib/   MyContext/  WebKit.cgi
Cache/      error404.html  Launch.py   Logs/  Sessions/   webkit*

Here's what the files and directories are for:

AppServer:

The script to start up the AppServer for this application. Each application will have its own AppServer, and its own process. If you are running under Windows, you will see a AppServer.bat instead and additionally, you will find a AppServerService.py script that can be used to start the AppServer as a service.

Cache:

A directory containing cache files. You won't need to look in here.

Configs:

Configuration files for the application. These files are copied from WebKit/Configs, but are specific to this application/AppServer.

error404.html:

The static HTML page to be displayed when a page is not found. You can remove this to display a standard error message, modify the page according to your preferences, or use a custom error servlet instead by setting ErrorPage in the Application.config file appropriately.

ErrorMsgs:

HTML pages for any errors that occur. These can pile up and take up considerable size (even just during development), so you'll want to purge these every so often.

Launch.py:

Called by the AppServer script to launch the AppServer.

Lib:

An example for an application-specific library package that can be created with the -l option (in this case, -l Lib). Import modules from this directory like from Lib.SitePage import SitePage.

Logs:

Logs of accesses.

MyContext:

The directory for your default context. This is where you put your servlets. you can change its name and location with the `-c and -d options. You can also change this subsequently in the Application.config file in the Configs directory, where you can also configure more than one context. You may also want to remove the other standard contexts that come with Webware from the config file.

Sessions:

Users sessions. These should be cleaned out automatically, you won't have to look in this directory.

WebKit.cgi:

A CGI script/adapter for accessing the AppServer here. You can still use the other adapters, but most of them don't need to be configured for the individual applications. I still recommend mod_webkit or wkcgi.

webkit*:

If you are running under Unix, you can use this as a start script (see webkit init script).

Stopping the App Server

The recommended method of stopping the AppServer is through the Application Control interface. This is a servlet located in the Admin context. A username and password are required -- the username is always admin, and the password is set when you run install.py. (You can change the password through the WebKit/Configs/Application.config file). This shutdown method is safer than doing a Control-C from a terminal, as described below.

On all OSs, stopping the app server may also be accomplished by simply going to its terminal/command window and hitting Control-C. The app server is designed to intercept this interruption and shut down as gracefully as possible. This includes saving session data to disk, if necessary.

On Unix, a running appserver may be stopped from a terminal by typing ./AppServer stop.

On Windows Control-C normally shuts the app server down gracefully, where as Control-Break does not. Keep that in mind and use Control-C, unless the server is unresponsive to it.

On Unix if you don't have access to the terminal window of the app server (perhaps because you used rlogin, telnet or ssh to remotely access the machine), and "AppServer stop" doesn't work, you can use ps -ax | grep ThreadedAppServer to get the pid and kill <pid> to effect a Control-C.

Reloading Servlets

As you develop your web application, you will change the code of your various Python classes, including your servlets. The WebKit app server will detect a change in the timestamp of a servlet's source file and automatically reload it for you.

However, reloading fails in two areas. The first is that WebKit doesn't check ancestor classes of servlets for modifications. So if you modify an abstract class (for example, SitePage, AccountPage, etc.), it won't be reloaded. The second is that WebKit can't check non-servlet classes. So if you modify a utility class (for example, ShoppingCart, Story, etc.), it won't be reloaded.

While developing this will happen quite often. There is a setting in WebKit/Configs/AppServer.config that you should turn on early in your experimentations.

The line:

'AutoReload':      0,

in AppServer.config controls a feature where the AppServer stops and restarts itself if any loaded modules have been changed.

You can also deal with reloading problems by stopping the app server (Control-C in its terminal/command window) and restarting it. And an alternative way of reloading ancestor classes is through the Application Control servlet, in the Admin context, which will provide a list of all of the currently loaded modules, and allow you to reload selected modules. Be warned, reloading modules can cause strange behavior, because instances of objects attached to the old class definitions can still exist. AutoReload is generally the best solution.

Launching the AppServer at Unix boot up

The script WebKit/webkit is a Unix shell script launching WebKit at boot time through the standard "init" mechanisms.

There are several variants of this script for various flavors of Unix available in the folder WebKit/StartScripts. The install.py script copies the variant that it thinks is the best fit to WebKit/webkit. If the script does not fit to your system, you may want to try out other variants or the Generic script that should fit on most systems.

If you create a working directory using bin/MakeAppWorkDir.py as explained above, the webkit start script will also be copied to the working directory.

In order to start WebKit at boot time, copy this script to the system folder that is destined for start scripts, which is usually /etc/init.d/ (e.g. for SuSE or Debian Linux or Solaris) or /etc/rc.d/init.d/ (e.g. for RedHat or Mandrake Linux). Instead of copying the script, you can also make a symbolic link refering to the script located in your working directory. If you do this, the script will be able to determine the location of the working directory from the symbolic link and you do not have to set the location in the script itself.

WORK_DIR      the location of your working directory

LOG_FILE      the location of the log file which records the standard
              and error output of the application server

PID_FILE      the location of the pid file which records the process id
              of the Python application server

WEBWARE_USER  the user to run the application server

> ./webkit start

> ./webkit stop

> cd /etc/rc0.d
> ln -s ../init.d/webkit K75webkit
(repeat for rc1.d and rc6.d)
> cd /etc/rc2.d
> ln -s ../init.d/webkit S25webkit
(repeat for rc3.d, rc4.d, and rc5.d)

Running ThreadedAppServer as a Windows NT/2K/XP Service

AppServerService is a script that runs the ThreadedAppServer as a Windows NT Service. This means it can be started and stopped from the Control Panel or from the command line using net start and net stop, and it can be configured in the Control Panel to auto-start when the machine boots. This is the preferred way to deploy WebKit on a Windows NT/2K/XP platform.

AppServerService requires the Python win32all extensions to have been installed.

To see the options for installing, removing, starting, and stopping the service, just run AppServerService.py with no arguments. Typical usage is to install the service to run under a particular user account and startup automatically on reboot with:

> python AppServerService.py ^
  --username mydomain\myusername ^
  --password mypassword --startup auto install

(Note: The caret (^) is the line continuation character under Windows.)

Then, you can start the service from the Services applet in the Control Panel, where it will be listed as "WebKit Application Server". Or, from the command line, it can be started with either of the following commands:

> net start WebKit
> python AppServerService.py start

The service can be stopped from the Control Panel or with:

> net stop WebKit
> python AppServerService.py stop

And finally, to uninstall the service, stop it and then run:

> python AppServerService.py remove

Other Notes

See Stopping the App Server and Reloading Servlets above in Adapters.

Bad Marshal Data

The most common installation problem is a Python exception appearing in your browser that says "bad marshal data". This is always caused by pointing the web browser to the app server:

http://localhost:8086/WebKit.cgi/

But the app server hides behind a web server so the correct URL would be:

http://localhost/WebKit.cgi/

That requires that web server and app server are set up to talk to each other. And that's what the Adapters section is all about...