WebKit.DebugAppServer | index /usr/local/share/webware/WebKit/DebugAppServer.py

`DebugAppServer
`DebugAppServer` executes all requests within the main thread, allowing
servlets to be easily debugged using any Python debugger. The drawback is
that only one request can be processed at a time using this approach.
Also, exceptions are not caught and gracefully handled with an HTML error
page. Instead, the exceptions rise uncaught which allows the debugger to
trap them so you can inspect the program.
To use, simply run "python Launch.py DebugAppServer" using whatever debugging
environment you prefer.
Caveats:
This app server supports the AutoReload feature but not for Python's standard
modules or WebKit or WebKit's dependencies (MiscUtils, WebUtils and TaskKit).
Even with that limitation, auto-reload is still useful because if you modify
any module in your site, the auto-reload will happen. Note that the app server
*will* restart when the aformentioned modules are modified, but the modules
won't actually be reloaded.
Currently the session sweeper is still run within a separate thread, and
a "close thread" is started up by the AppServer base class, but neither
of these two extra threads should pose any problems debugging servlets.
Tested on:
- WingIDE on Windows, http://wingware.com/
- PythonWin
- JEdit with the JPyDbg plugin, on Windows`

Modules
`` |  |
WebKit.Profiler WebKit.ThreadedAppServer | WebUtils os | sys time |

Classes
`` |  | WebKit.Application.Application(WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath, WebKit.Object.Object) DebugApplication DummyRequestQueue WebKit.ThreadedAppServer.ThreadedAppServer(WebKit.AutoReloadingAppServer.AutoReloadingAppServer) DebugAppServer
class DebugAppServer(WebKit.ThreadedAppServer.ThreadedAppServer)
`` | `Single-threaded AppServer for debugging purposes. We are piggybacking on 99% of the code in ThreadedAppServer. Our trick is to replace the request queue with a dummy object that executes requests immediately instead of pushing them onto a queue to be handled by other threads.`
| Method resolution order: DebugAppServer WebKit.ThreadedAppServer.ThreadedAppServer WebKit.AutoReloadingAppServer.AutoReloadingAppServer WebKit.AppServer.AppServer WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath MiscUtils.Configurable.Configurable WebKit.Object.Object __builtin__.object MiscUtils.NamedValueAccess.NamedValueAccess Methods defined here: __init__(self, path=None) `Initialize DebugAppServer.` config(self) `Return default configuration.` createApplication(self) `Create and return an application object. Invoked by __init__.` mainloop(self) `Main loop for Windows. This is needed for COM support on Windows, because special thread initialization is required on any thread that runs servlets, in this case the main thread itself.` restart(self) Methods inherited from WebKit.ThreadedAppServer.ThreadedAppServer: absorbThread(self, count=1) `Absorb a thread. We do this by putting a None on the Queue. When a thread gets it, that tells it to exit. We also keep track of the threads, so after killing threads we go through all the threads and find the thread(s) that have exited, so that we can take them out of the thread pool.` activeThreadCount(self) `Get a snapshot of the number of threads currently in use. Called from `updateThreadUsage`.` addSocketHandler(self, handlerClass, serverAddress=None) `Add socket handler. Adds a socket handler for `serverAddress` -- `serverAddress` is a tuple (*host*, *port*), where *host* is the interface to connect to (for instance, the IP address on a machine with multiple IP numbers), and *port* is the port (e.g. HTTP is on 80 by default, and Webware adapters use 8086 by default). The `handlerClass` is a subclass of `Handler`, and is used to handle the actual request -- usually returning control back to ThreadedAppServer in some fashion. See `Handler` for more.` address(self, settingPrefix) `Get host address. The address for the Adapter (Host/interface, and port), as taken from ``Configs/AppServer.config``, settings ``Host`` and ``AdapterPort``.` addressFileName(self, handlerClass) `Get the name of the text file with the server address.` awakeSelect(self) `Awake the select() call. The ``select()`` in `mainloop()` is blocking, so when we shut down we have to make a connect to unblock it. Here's where we do that.` defaultConfig(self) `The default AppServer.config.` delThread(self) `Delete thread. Invoked immediately by threadloop() as a hook for subclasses. This implementation does nothing and subclasses need not invoke super.` initThread(self) `Initialize thread. Invoked immediately by threadloop() as a hook for subclasses. This implementation does nothing and subclasses need not invoke super.` isPersistent(self) manageThreadCount(self) `Adjust the number of threads in use. From information gleened from `updateThreadUsage`, we see about how many threads are being used, to see if we have too many threads or too few. Based on this we create or absorb threads.` shutDown(self) `Called on shutdown. Also calls `AppServer.shutDown`, but first closes all sockets and tells all the threads to die.` spawnThread(self) `Create a new worker thread. Worker threads poll with the `threadloop` method.` threadloop(self) `The main loop for worker threads. Worker threads poll the ``_requestQueue`` to find a request handler waiting to run. If they find a None in the queue, this thread has been selected to die, which is the way the loop ends. The handler object does all the work when its `handleRequest` method is called. `initThread` and `delThread` methods are called at the beginning and end of the thread loop, but they aren't being used for anything (future use as a hook).` updateThreadUsage(self) `Update the threadUseCounter list. Called periodically from `mainloop`.` Methods inherited from WebKit.AutoReloadingAppServer.AutoReloadingAppServer: activateAutoReload(self) `Start the monitor thread.` deactivateAutoReload(self) `Stop the monitor thread.` fileMonitorThreadLoop(self) `This the the main loop for the monitoring thread. Runs in its own thread, polling the files for changes directly (i.e., going through every file that's being used and checking its last-modified time, seeing if it's been changed since it was initially loaded).` fileMonitorThreadLoopFAM(self, getmtime=<function getmtime at 0x4834b534>) `Monitoring thread loop, but using the FAM library.` monitorNewModule(self, filepath, mtime=None) `Add new file to be monitored. This is a callback which ImportSpy invokes to notify us of new files to monitor. This is only used when we are using FAM.` restartIfNecessary(self) `Check if the app server should be restarted. This should be called regularly to see if a restart is required. The server can only restart from the main thread, other threads can't do the restart. So this polls to see if `shouldRestart` has been called.` shouldRestart(self) `Tell the main thread to restart the server.` Methods inherited from WebKit.AppServer.AppServer: application(self) `Return the Application singleton.` checkForInstall(self) `Check whether Webware was installed. Exits with an error message if Webware was not installed. Called from `__init__`.` closeThread(self) `This method is called when the shutdown sequence is initiated.` configFilename(self) `Return the name of the AppServer configuration file.` configReplacementValues(self) `Get config values that need to be escaped.` initiateShutdown(self) `Ask the master thread to begin the shutdown.` loadPlugIn(self, path) `Load and return the given plug-in. May return None if loading was unsuccessful (in which case this method prints a message saying so). Used by `loadPlugIns` (note the **s**).` loadPlugIns(self) `Load all plug-ins. A plug-in allows you to extend the functionality of WebKit without necessarily having to modify its source. Plug-ins are loaded by AppServer at startup time, just before listening for requests. See the docs in `WebKit.PlugIn` for more info.` numRequests(self) `Return the number of requests. Returns the number of requests received by this app server since it was launched.` plugIn(self, name, default=<class MiscUtils.NoDefault at 0x4842f9bc>) `Return the plug-in with the given name.` plugIns(self) `Return a list of the plug-ins loaded by the app server. Each plug-in is a Python package.` printStartUpMessage(self) `Invoked by __init__, prints a little intro.` readyForRequests(self) `Declare ready for getting requests. Should be invoked by subclasses when they are finally ready to accept requests. Records some stats and prints a message.` recordPID(self) `Save the pid of the AppServer to a file.` serverSidePath(self, path=None) `Return the absolute server-side path of the WebKit app server. If the optional path is passed in, then it is joined with the server side directory to form a path relative to the app server.` startTime(self) `Return the time the app server was started. The time is given as seconds, like time().` version(self) `Return WebKit version.` webKitPath(self) `Return teh WebKit path.` webwarePath(self) `Return the Webware path.` Methods inherited from WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath: setting(self, name, default=<class MiscUtils.NoDefault at 0x4842f9bc>) `Returns the setting, filtered by serverSidePath(), if the name ends with ``Filename`` or ``Dir``.` Methods inherited from MiscUtils.Configurable.Configurable: commandLineConfig(self) `Return the settings that came from the command-line. These settings come via addCommandLineSetting().` configName(self) `Return the name of the configuration file without the extension. This is the portion of the config file name before the '.config'. This is used on the command-line.` hasSetting(self, name) `Check whether a configuration setting has been changed.` printConfig(self, dest=None) `Print the configuration to the given destination. The default destionation is stdout. A fixed with font is assumed for aligning the values to start at the same column.` setSetting(self, name, value) `Set a particular configuration setting.` userConfig(self) `Return the user config overrides. These settings can be found in the optional config file. Returns {} if there is no such file. The config filename is taken from configFilename().` Methods inherited from WebKit.Object.Object: deprecated(self, method) `Output a deprecation warning. The implementation of WebKit sometimes invokes this method which prints a warning that the method you are using has been deprecated. This method expects that deprecated methods say so at the beginning of their doc string and terminate that msg with @. For example: DEPRECATED: Class.foo() on 01/24/01 in ver 0.5. Use Class.bar() instead. @ Putting this information in the doc string is important for accuracy in the generated docs. Example call: deprecated(self.foo)` Data descriptors inherited from WebKit.Object.Object: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)` Methods inherited from MiscUtils.NamedValueAccess.NamedValueAccess: handleUnknownSetKey(self, key) hasValueForKey(self, key) `Check whether key is available. Returns true if the key is available, although that does not guarantee that there will not be errors caused by retrieving the key.` hasValueForName(self, keysString) `Check whether name is available.` resetKeyBindings(self) `Rest all key bindings, releasing alreaedy referenced values.` setValueForKey(self, key, value) `Set value for a given key. Suppose key is 'foo'. This method sets the value with the following precedence: 1. Public attributes before private attributes 2. Methods before non-methods More specifically, this method then uses one of the following: @@ 2000-03-04 ce: fill in ... or invokes handleUnknownSetKey().` valueForKey(self, key, default=<class MiscUtils.NoDefault at 0x4842f9bc>) `Get value for given key. Suppose key is 'foo'. This method returns the value with the following precedence: 1. Methods before non-methods 2. Public attributes before private attributes More specifically, this method then returns one of the following: * foo() * _foo() * self.foo * self._foo ... or default, if it was specified, otherwise invokes and returns result of valueForUnknownKey(). Note that valueForUnknownKey() normally returns an exception. See valueForName() which is a more advanced version of this method that allows multiple, qualified keys.` valueForKeySequence(self, listOfKeys, default=None) `Get the value for the given list of keys.` valueForName(self, keysString, default=None) `Get the value for the given keysString. This is the more advanced version of valueForKey(), which can only handle single names. This method can handle 'foo', 'foo1.foo2', 'a.b.c.d', etc. It will traverse dictionaries if needed.` valueForUnknownKey(self, key, default) valuesForNames(self, keys, default=None, defaults=None, forgive=0, includeNames=0) `Get all values for given names. Returns a list of values that match the given keys, each of which is passed through valueForName() and so could be of the form 'a.b.c'. keys and defaults are sequences. default is any kind of object. forgive and includeNames are flags. If default is not None, then it is substituted when a key is not found. Otherwise, if defaults is not None, then it's corresponding/parallel value for the current key is substituted when a key is not found. Otherwise, if forgive is true, then unknown keys simply don't produce any values. Otherwise, if default and defaults are None, and forgive is false, then the unknown keys will probably raise an exception through valueForUnknownKey() although that method can always return a final, default value. if keys is None, then None is returned. If keys is an empty list, then None is returned. Often these last four arguments are specified by key. Examples: names = ['origin.x', 'origin.y', 'size.width', 'size.height'] obj.valuesForNames(names) obj.valuesForNames(names, default=0.0) obj.valuesForNames(names, defaults=[0.0, 0.0, 100.0, 100.0]) obj.valuesForNames(names, forgive=0) @@ 2000-03-04 ce: includeNames is only supported when forgive=1. It should be supported for the other cases. It should be documented. It should be included in the test cases.`
class DebugApplication(WebKit.Application.Application)
`` | `This is a modified Application class for debugging.`
| Method resolution order: DebugApplication WebKit.Application.Application WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath MiscUtils.Configurable.Configurable WebKit.Object.Object __builtin__.object MiscUtils.NamedValueAccess.NamedValueAccess Methods defined here: handleException(self) `Handle exception. This should only be used in cases where there is no transaction object, for example if an exception occurs when attempting to save a session to disk.` handleExceptionInTransaction(self, excInfo, transaction) `Handle exception with info. Raises exception `excInfo` (as returned by ``sys.exc_info()``) that was generated by `transaction`.` Methods inherited from WebKit.Application.Application: __init__(self, server, useSessionSweeper=1) `Called only by `AppServer`, sets up the Application.` addContext(self, name, path) `Add a context by named `name`, rooted at `path`. This gets imported as a package, and the last directory of `path` does not have to match the context name. (The package will be named `name`, regardless of `path`). Delegated to `URLParser.ContextParser`.` addServletFactory(self, factory) `Add a ServletFactory. Delegated to the `URLParser.ServletFactoryManager` singleton.` addShutDownHandler(self, func) `Add a shutdown handler. Functions added through `addShutDownHandler` will be called when the AppServer is shutting down. You can use this hook to close database connections, clean up resources, save data to disk, etc.` callMethodOfServlet(self, trans, url, method, *args, **kw) `Call method of another servlet. Call a method of the servlet referred to by the URL. Calls sleep() and awake() before and after the method call. Or, if the servlet defines it, then `runMethodForTransaction` is used (analogous to the use of `runTransaction` in `forward`). The entire process is similar to `forward`, except that instead of `respond`, `method` is called (`method` should be a string, ``*args`` and ``**kw`` are passed as arguments to that method).` configFilename(self) configReplacementValues(self) contexts(self) `Return a dictionary of context-name: context-path.` createRequestForDict(self, requestDict) `Create request object for a given dictionary. Create a request object (subclass of `Request`) given the raw dictionary as passed by the adapter. The class of the request may be based on the contents of the dictionary (though only `HTTPRequest` is currently created), and the request will later determine the class of the response. Called by `dispatchRawRequest`.` createSessionForTransaction(self, trans) `Get the session object for the transaction. If the session already exists, returns that, otherwise creates a new session. Finding the session ID is done in `Transaction.sessionId`.` createSessionWithID(self, trans, sessionID) `Create a session object with our session ID.` defaultConfig(self) `The default Application.config.` dispatchRawRequest(self, requestDict, strmOut) `Dispatch a raw request. Dispatch a request as passed from the Adapter through the AppServer. This method creates the request, response, and transaction object, then runs (via `runTransaction`) the transaction. It also catches any exceptions, which are then passed on to `handleExceptionInTransaction`.` errorPage(self, errorClass) `Get the error page url corresponding to an error class.` forward(self, trans, url) `Forward the request to a different (internal) URL. The transaction's URL is changed to point to the new servlet, and the transaction is simply run again. Output is _not_ accumulated, so if the original servlet had any output, the new output will _replace_ the old output. You can change the request in place to control the servlet you are forwarding to -- using methods like `HTTPRequest.setField`.` handleMissingPathSession(self, trans) `Redirect requests without session info in the path. if UseAutomaticPathSessions is enabled in Application.config we redirect the browser to a url with SID in path http://gandalf/a/_SID_=2001080221301877755/Examples/ _SID_ is extracted and removed from path in HTTPRequest.py This is for convinient building of webapps that must not depend on cookie support.` handlePathSession(self, trans) `Handle the session identifier that has been found in the path.` handleUnnecessaryPathSession(self, trans) `Redirect request with unnecessary session info in the path. This is called if it has been determined that the request has a path session, but also cookies. In that case we redirect to eliminate the unnecessary path session.` hasContext(self, name) `Checks whether context `name` exist.` hasSession(self, sessionId) `Check whether session `sessionId` exists.` includeURL(self, trans, url) `Include another servlet. Include the servlet given by the URL. Like `forward`, except control is ultimately returned to the servlet.` initErrorPage(self) `Initialize the error page related attributes.` initSessions(self) `Initialize all session related attributes.` initVersions(self) `Get and store versions. Initialize attributes that store the Webware and WebKit versions as both tuples and strings. These are stored in the Properties.py files.` makeDirs(self) `Make sure some standard directories are always available.` name(self) `The name by which this was started. Usually ``AppServer``.` removePathSession(self, trans) `Remove a possible session identifier from the path.` resolveInternalRelativePath(self, trans, url) `Return the absolute internal path. Given a URL, return the absolute internal URL. URLs are assumed relative to the current URL. Absolute paths are returned unchanged.` returnServlet(self, servlet) `Return the servlet to its pool.` rootURLParser(self) `Accessor: the Rool URL parser. URL parsing (as defined by subclasses of `URLParser.URLParser`) starts here. Other parsers are called in turn by this parser.` runTransaction(self, trans) `Run transation. Executes the transaction, handling HTTPException errors. Finds the servlet (using the root parser, probably `URLParser.ContextParser`, to find the servlet for the transaction, then calling `runTransactionViaServlet`. Called by `dispatchRawRequest`.` runTransactionViaServlet(self, servlet, trans) `Execute the transaction using the servlet. This is the `awake`/`respond`/`sleep` sequence of calls, or if the servlet supports it, a single `runTransaction` call (which is presumed to make the awake/respond/sleep calls on its own). Using `runTransaction` allows the servlet to override the basic call sequence, or catch errors from that sequence. Called by `runTransaction`.` server(self) `Acessor: the AppServer` serverSidePath(self, path=None) `Get the serve-side-path. Returns the absolute server-side path of the WebKit application. If the optional path is passed in, then it is joined with the server side directory to form a path relative to the app server.` session(self, sessionId, default=<class MiscUtils.NoDefault at 0x4842f9bc>) `The session object for `sessionId`. Raises ``KeyError`` if session not found and no default is given.` sessionCookiePath(self, trans) `Get the cookie path for this transaction. If not path is specified in the configuration setting, the servlet path is used for security reasons, see: http://www.net-security.org/dl/articles/cookie_path.pdf` sessionName(self, trans) `Get the name of the field holding the session ID. Overwrite to make this transaction dependent.` sessionPrefix(self, trans) `Get the prefix string for the session ID. Overwrite to make this transaction dependent.` sessionTimeout(self, trans) `Get the timeout (in seconds) for a user session. Overwrite to make this transaction dependent.` sessions(self) `A dictionary of all the session objects.` shutDown(self) `Shut down the application. Called by AppServer when it is shuting down. The `__del__` function of Application probably won't be called due to circular references.` startSessionSweeper(self) `Start session sweeper. Starts the session sweeper, `WebKit.Tasks.SessionTask`, which deletes session objects (and disk copies of those objects) that have expired.` taskManager(self) `Accessor: `TaskKit.Scheduler` instance.` webKitPath(self) `The Path of the ``Webware/WebKit/`` directory.` webKitVersion(self) `Return the WebKit version as a tuple.` webKitVersionString(self) `Return the WebKit version as a printable string.` webwarePath(self) `The path of the ``Webware/`` directory.` webwareVersion(self) `Return the Webware version as a tuple.` webwareVersionString(self) `Return the Webware version as a printable string.` writeActivityLog(self, trans) `Write an entry to the activity log. Writes an entry to the script log file. Uses settings ``ActivityLogFilename`` and ``ActivityLogColumns``.` writeExceptionReport(self, handler) Methods inherited from WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath: setting(self, name, default=<class MiscUtils.NoDefault at 0x4842f9bc>) `Returns the setting, filtered by serverSidePath(), if the name ends with ``Filename`` or ``Dir``.` Methods inherited from MiscUtils.Configurable.Configurable: commandLineConfig(self) `Return the settings that came from the command-line. These settings come via addCommandLineSetting().` config(self) `Return the configuration of the object as a dictionary. This is a combination of defaultConfig() and userConfig(). This method caches the config.` configName(self) `Return the name of the configuration file without the extension. This is the portion of the config file name before the '.config'. This is used on the command-line.` hasSetting(self, name) `Check whether a configuration setting has been changed.` printConfig(self, dest=None) `Print the configuration to the given destination. The default destionation is stdout. A fixed with font is assumed for aligning the values to start at the same column.` setSetting(self, name, value) `Set a particular configuration setting.` userConfig(self) `Return the user config overrides. These settings can be found in the optional config file. Returns {} if there is no such file. The config filename is taken from configFilename().` Methods inherited from WebKit.Object.Object: deprecated(self, method) `Output a deprecation warning. The implementation of WebKit sometimes invokes this method which prints a warning that the method you are using has been deprecated. This method expects that deprecated methods say so at the beginning of their doc string and terminate that msg with @. For example: DEPRECATED: Class.foo() on 01/24/01 in ver 0.5. Use Class.bar() instead. @ Putting this information in the doc string is important for accuracy in the generated docs. Example call: deprecated(self.foo)` Data descriptors inherited from WebKit.Object.Object: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)` Methods inherited from MiscUtils.NamedValueAccess.NamedValueAccess: handleUnknownSetKey(self, key) hasValueForKey(self, key) `Check whether key is available. Returns true if the key is available, although that does not guarantee that there will not be errors caused by retrieving the key.` hasValueForName(self, keysString) `Check whether name is available.` resetKeyBindings(self) `Rest all key bindings, releasing alreaedy referenced values.` setValueForKey(self, key, value) `Set value for a given key. Suppose key is 'foo'. This method sets the value with the following precedence: 1. Public attributes before private attributes 2. Methods before non-methods More specifically, this method then uses one of the following: @@ 2000-03-04 ce: fill in ... or invokes handleUnknownSetKey().` valueForKey(self, key, default=<class MiscUtils.NoDefault at 0x4842f9bc>) `Get value for given key. Suppose key is 'foo'. This method returns the value with the following precedence: 1. Methods before non-methods 2. Public attributes before private attributes More specifically, this method then returns one of the following: * foo() * _foo() * self.foo * self._foo ... or default, if it was specified, otherwise invokes and returns result of valueForUnknownKey(). Note that valueForUnknownKey() normally returns an exception. See valueForName() which is a more advanced version of this method that allows multiple, qualified keys.` valueForKeySequence(self, listOfKeys, default=None) `Get the value for the given list of keys.` valueForName(self, keysString, default=None) `Get the value for the given keysString. This is the more advanced version of valueForKey(), which can only handle single names. This method can handle 'foo', 'foo1.foo2', 'a.b.c.d', etc. It will traverse dictionaries if needed.` valueForUnknownKey(self, key, default) valuesForNames(self, keys, default=None, defaults=None, forgive=0, includeNames=0) `Get all values for given names. Returns a list of values that match the given keys, each of which is passed through valueForName() and so could be of the form 'a.b.c'. keys and defaults are sequences. default is any kind of object. forgive and includeNames are flags. If default is not None, then it is substituted when a key is not found. Otherwise, if defaults is not None, then it's corresponding/parallel value for the current key is substituted when a key is not found. Otherwise, if forgive is true, then unknown keys simply don't produce any values. Otherwise, if default and defaults are None, and forgive is false, then the unknown keys will probably raise an exception through valueForUnknownKey() although that method can always return a final, default value. if keys is None, then None is returned. If keys is an empty list, then None is returned. Often these last four arguments are specified by key. Examples: names = ['origin.x', 'origin.y', 'size.width', 'size.height'] obj.valuesForNames(names) obj.valuesForNames(names, default=0.0) obj.valuesForNames(names, defaults=[0.0, 0.0, 100.0, 100.0]) obj.valuesForNames(names, forgive=0) @@ 2000-03-04 ce: includeNames is only supported when forgive=1. It should be supported for the other cases. It should be documented. It should be included in the test cases.`
class DummyRequestQueue
`` | `This is a dummy replacement for the request queue. It merely executes handlers as soon as they are "pushed".`
| Methods defined here: put(self, handler)

Functions
`` |  | StringIO(...) `StringIO([s]) -- Return a StringIO-like stream for reading or writing` runMainLoopInThread() `# Tweak ThreadedAppServer so that it never runs the main loop in a thread:`