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

`The Application singleton.
`Application` and `AppServer` work together to setup up and dispatch requests.
The distinction between the two is largely historical, but AppServer
communicates directly with Adapters (or speaks protocols like HTTP), and
Application receives the (slightly) processed input from AppServer and turns
it into `Transaction`, `HTTPRequest`, `HTTPResponse`, and `Session`.
Application is a singleton, which belongs to the AppServer. You can get access
through the Transaction object (`transaction.application()`), or you can do::
from AppServer import globalAppServer
application = globalAppServer.application()
Settings for Application are taken from ``Configs/Application.config``,
which is used for many global settings, even if they aren't closely tied
to the Application object itself.`

Modules

``

WebKit.URLParser WebUtils | os sys | time |

Classes

``

WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath(MiscUtils.Configurable.Configurable)
  Application(WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath, WebKit.Object.Object)
WebKit.Object.Object(__builtin__.object, MiscUtils.NamedValueAccess.NamedValueAccess)
  Application(WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath, WebKit.Object.Object)
exceptions.Exception(exceptions.BaseException)
  EndResponse

class Application(WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath, WebKit.Object.Object)
`` | `The Application singleton. Purpose and usage are explained in the module docstring.`

Method resolution order:
  Application
  WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath
  MiscUtils.Configurable.Configurable
  WebKit.Object.Object
  __builtin__.object
  MiscUtils.NamedValueAccess.NamedValueAccess

Methods defined here:

__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`.`

handleException(self)
  `Handle exceptions.
  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, trans)
  `Handle exception with info.
  Handles exception `excInfo` (as returned by `sys.exc_info()`)
  that was generated by `transaction`. It may display the exception
  report, email the report, etc., handled by
  `ExceptionHandler.ExceptionHandler`.`

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 server-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 0x832da1c>)
  `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 0x832da1c>)
  `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 0x832da1c>)
  `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 EndResponse(exceptions.Exception)
`` | `End response exception. Used to prematurely break out of the awake()/respond()/sleep() cycle without reporting a traceback. During servlet processing, if this exception is caught during awake() or respond() then sleep() is called and the response is sent. If caught during sleep(), processing ends and the response is sent.`

Method resolution order:
  EndResponse
  exceptions.Exception
  exceptions.BaseException
  __builtin__.object

Data descriptors defined here:

__weakref__
  `list of weak references to the object (if defined)`

Methods inherited from exceptions.Exception:

__init__(...)
  `x.__init__(...) initializes x; see x.__class__.__doc__ for signature`

Data and other attributes inherited from exceptions.Exception:

__new__ = <built-in method __new__ of type object at 0x8118b60>
  `T.__new__(S, ...) -> a new object with type S, a subtype of T`

Methods inherited from exceptions.BaseException:

__delattr__(...)
  `x.__delattr__('name') <==> del x.name`

__getattribute__(...)
  `x.__getattribute__('name') <==> x.name`

__getitem__(...)
  `x.__getitem__(y) <==> x[y]`

__getslice__(...)
  `x.__getslice__(i, j) <==> x[i:j]
  Use of negative indices is not supported.`

__reduce__(...)

__repr__(...)
  `x.__repr__() <==> repr(x)`

__setattr__(...)
  `x.__setattr__('name', value) <==> x.name = value`

__setstate__(...)

__str__(...)
  `x.__str__() <==> str(x)`

Data descriptors inherited from exceptions.BaseException:

__dict__

args

message
  `exception message`

Functions

``

StringIO(...)
  `StringIO([s]) -- Return a StringIO-like stream for reading or writing`

Data

``

debug = False
defaultConfig = {'ActivityLogColumns': ['request.remoteAddress', 'request.method', 'request.uri', 'response.size', 'servlet.name', 'request.timeStamp', 'transaction.duration', 'transaction.errorOccurred'], 'ActivityLogFilename': 'Logs/Activity.csv', 'CacheDir': 'Cache', 'Contexts': {'Admin': 'Admin', 'Docs': 'Docs', 'Examples': 'Examples', 'Testing': 'Testing', 'default': 'Examples'}, 'Debug': {'Sessions': False}, 'DirectoryFile': ['index', 'Index', 'main', 'Main'], 'EmailErrorReportAsAttachment': False, 'EmailErrors': False, 'EnterDebuggerOnException': False, 'ErrorEmailHeaders': {'From': 'webware@mydomain', 'Reply-to': 'webware@mydomain', 'Subject': 'Error', 'To': ['webware@mydomain'], 'content-type': 'text/html'}, ...}