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

`Threaded Application Server
The AppServer is the main process of WebKit. It handles requests for
servlets from webservers.
ThreadedAppServer uses a threaded model for handling multiple requests.
At one time there were other experimental execution models for AppServer,
but none of these were successful and have been removed.
The ThreadedAppServer/AppServer distinction is thus largely historical.
ThreadedAppServer takes the following command line arguments:
start: start the AppServer (default argument)
stop: stop the currently running Apperver
daemon: run as a daemon
ClassName.SettingName=value: change configuration settings
When started, the app server records its pid in appserver.pid.`

Modules
`` |  |
WebKit.AppServer MiscUtils.Configurable Queue errno | fcntl os re select | signal socket sys threading | traceback

Classes
`` |  | WebKit.ASStreamOut.ASStreamOut(__builtin__.object) TASStreamOut WebKit.AutoReloadingAppServer.AutoReloadingAppServer(WebKit.AppServer.AppServer) ThreadedAppServer WebKit.HTTPExceptions.HTTPServiceUnavailable(WebKit.HTTPExceptions.HTTPException) ThreadAbortedError RequestAbortedError RequestTooLongError ServerShutDownError __builtin__.object Handler AdapterHandler SCGIHandler MonitorHandler exceptions.Exception(exceptions.BaseException) NotEnoughDataError ProtocolError RestartAppServerError threading.Thread(threading._Verbose) WorkerThread
class AdapterHandler(Handler)
`` | `Adapter handler. Handles the Adapter protocol (as used in mod_webkit, wkcgi, WebKit.cgi, HTTPAdapter, etc). This protocol passes a marshalled dictionary which contains the keys ``format`` and ``environ``. ``format`` is currently always the string ``CGI``, and ``environ`` is a dictionary of string: string, with values like those passed in the environment to a CGI request (QUERY_STRING, HTTP_HOST, etc). The handler adds one more key, ``input``, which contains a file object based off the socket, which contains the body of the request (the POST data, for instance). It's left to Application to handle that data.`
| Method resolution order: AdapterHandler Handler __builtin__.object Methods defined here: handleRequest(self) `Handle request. Creates the request dictionary, and creates a `TASStreamOut` object for the response, then calls `Application.dispatchRawRequest`, which does the rest of the work (here we just clean up after).` makeInput(self) `Create a file-like object from the socket.` Data and other attributes defined here: protocolName = 'adapter' settingPrefix = 'Adapter' Methods inherited from Handler: __init__(self, server, serverAddress) `Create a new socket handler. Each handler is attached to a specific host and port, and of course to the AppServer.` activate(self, sock, requestID) `Activate the handler for processing the request. `sock` is the incoming socket that this handler will work with, and `requestID` is a serial number unique for each request. This isn't where work gets done -- the handler is queued after this, and work is done when `handleRequest` is called.` close(self) `Close the socket. Called when the handler is finished. Closes the socket and returns the handler to the pool of inactive handlers.` endRequest(self, error=None) `Track end of a raw request. Subclasses can use and override this method.` receiveDict(self) `Receive a dictionary from the socket. Utility function to receive a marshalled dictionary from the socket. Returns None if the request was empty.` startRequest(self, requestDict=None) `Track start of a raw request. Subclasses can use and override this method.` Data descriptors inherited from Handler: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class Handler(__builtin__.object)
`` | `A very general socket handler. Handler is an abstract superclass -- specific protocol implementations will subclass this. A Handler takes a socket to interact with, and creates a raw request. Handlers will be reused. When a socket is received `activate` will be called -- but the handler should not do anything, as it is still running in the main thread. The handler is put into a queue, and a worker thread picks it up and runs `handleRequest`, which subclasses should override. Several methods are provided which are typically used by subclasses.`
| Methods defined here: __init__(self, server, serverAddress) `Create a new socket handler. Each handler is attached to a specific host and port, and of course to the AppServer.` activate(self, sock, requestID) `Activate the handler for processing the request. `sock` is the incoming socket that this handler will work with, and `requestID` is a serial number unique for each request. This isn't where work gets done -- the handler is queued after this, and work is done when `handleRequest` is called.` close(self) `Close the socket. Called when the handler is finished. Closes the socket and returns the handler to the pool of inactive handlers.` endRequest(self, error=None) `Track end of a raw request. Subclasses can use and override this method.` handleRequest(self) `Handle a raw request. This is where the work gets done. Subclasses should override.` receiveDict(self) `Receive a dictionary from the socket. Utility function to receive a marshalled dictionary from the socket. Returns None if the request was empty.` startRequest(self, requestDict=None) `Track start of a raw request. Subclasses can use and override this method.` Data descriptors defined here: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class MonitorHandler(Handler)
`` | `Monitor server status. Monitor is a minimal service that accepts a simple protocol, and returns a value indicating the status of the server. The protocol passes a marshalled dict, much like the Adapter interface, which looks like ``{'format': 'CMD'}``, where CMD is a command (``STATUS`` or ``QUIT``). Responds with a simple string, either the number of requests we've received (for ``STATUS``) or ``OK`` for ``QUIT`` (which also stops the server).`
| Method resolution order: MonitorHandler Handler __builtin__.object Methods defined here: handleRequest(self) Data and other attributes defined here: protocolName = 'monitor' settingPrefix = 'Monitor' Methods inherited from Handler: __init__(self, server, serverAddress) `Create a new socket handler. Each handler is attached to a specific host and port, and of course to the AppServer.` activate(self, sock, requestID) `Activate the handler for processing the request. `sock` is the incoming socket that this handler will work with, and `requestID` is a serial number unique for each request. This isn't where work gets done -- the handler is queued after this, and work is done when `handleRequest` is called.` close(self) `Close the socket. Called when the handler is finished. Closes the socket and returns the handler to the pool of inactive handlers.` endRequest(self, error=None) `Track end of a raw request. Subclasses can use and override this method.` receiveDict(self) `Receive a dictionary from the socket. Utility function to receive a marshalled dictionary from the socket. Returns None if the request was empty.` startRequest(self, requestDict=None) `Track start of a raw request. Subclasses can use and override this method.` Data descriptors inherited from Handler: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class NotEnoughDataError(exceptions.Exception)
`` | `Not enough data received error`
| Method resolution order: NotEnoughDataError 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 help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `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)` __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message
class ProtocolError(exceptions.Exception)
`` | `Network protocol error`
| Method resolution order: ProtocolError 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 help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `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)` __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message
class RequestAbortedError(ThreadAbortedError)
`` | `Request aborted error`
| Method resolution order: RequestAbortedError ThreadAbortedError WebKit.HTTPExceptions.HTTPServiceUnavailable WebKit.HTTPExceptions.HTTPException exceptions.Exception exceptions.BaseException __builtin__.object Methods inherited from WebKit.HTTPExceptions.HTTPException: __str__(self) code(self) `The integer code.` codeMessage(self) `The message (like ``Not Found``) that goes with the code.` description(self) `Error description. Possibly a plain text version of the error description, though usually just identical to `htDescription`.` headers(self) `Get headers. Additional headers that should be sent with the response, not including the Status header. For instance, the redirect exception adds a Location header.` htBody(self) `The HTML body of the page.` htDescription(self) `HTML error description. The HTML description of the error, for presentation to the browser user.` htTitle(self) `The title, but it may include HTML markup (like italics).` html(self) `The error page. The HTML page that should be sent with the error, usually a description of the problem.` setTransaction(self, trans) `Set transaction. When the exception is caught by `Application`, it tells the exception what the transaction is. This way you can resolve relative paths, or otherwise act in a manner sensitive of the context of the error.` title(self) `The title used in the HTML page.` Data descriptors inherited from WebKit.HTTPExceptions.HTTPException: __weakref__ `list of weak references to the object (if defined)` Methods inherited from exceptions.Exception: __init__(...) `x.__init__(...) initializes x; see help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `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__(...) __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message
class RequestTooLongError(RequestAbortedError)
`` | `Request lasts too long error`
| Method resolution order: RequestTooLongError RequestAbortedError ThreadAbortedError WebKit.HTTPExceptions.HTTPServiceUnavailable WebKit.HTTPExceptions.HTTPException exceptions.Exception exceptions.BaseException __builtin__.object Methods inherited from WebKit.HTTPExceptions.HTTPException: __str__(self) code(self) `The integer code.` codeMessage(self) `The message (like ``Not Found``) that goes with the code.` description(self) `Error description. Possibly a plain text version of the error description, though usually just identical to `htDescription`.` headers(self) `Get headers. Additional headers that should be sent with the response, not including the Status header. For instance, the redirect exception adds a Location header.` htBody(self) `The HTML body of the page.` htDescription(self) `HTML error description. The HTML description of the error, for presentation to the browser user.` htTitle(self) `The title, but it may include HTML markup (like italics).` html(self) `The error page. The HTML page that should be sent with the error, usually a description of the problem.` setTransaction(self, trans) `Set transaction. When the exception is caught by `Application`, it tells the exception what the transaction is. This way you can resolve relative paths, or otherwise act in a manner sensitive of the context of the error.` title(self) `The title used in the HTML page.` Data descriptors inherited from WebKit.HTTPExceptions.HTTPException: __weakref__ `list of weak references to the object (if defined)` Methods inherited from exceptions.Exception: __init__(...) `x.__init__(...) initializes x; see help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `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__(...) __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message
class RestartAppServerError(exceptions.Exception)
`` | `Raised by DebugAppServer when needed.`
| Method resolution order: RestartAppServerError 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 help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `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)` __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message
class SCGIHandler(AdapterHandler)
`` | `SCGI handler. Modified Adapter handler speaking the SCGI protocol.`
| Method resolution order: SCGIHandler AdapterHandler Handler __builtin__.object Methods defined here: receiveDict(self) `Receive a dictionary from the socket. Utility function to receive the SCGI headers from the socket. Returns None if the request was empty.` Data and other attributes defined here: protocolName = 'scgi' settingPrefix = 'SCGI' Methods inherited from AdapterHandler: handleRequest(self) `Handle request. Creates the request dictionary, and creates a `TASStreamOut` object for the response, then calls `Application.dispatchRawRequest`, which does the rest of the work (here we just clean up after).` makeInput(self) `Create a file-like object from the socket.` Methods inherited from Handler: __init__(self, server, serverAddress) `Create a new socket handler. Each handler is attached to a specific host and port, and of course to the AppServer.` activate(self, sock, requestID) `Activate the handler for processing the request. `sock` is the incoming socket that this handler will work with, and `requestID` is a serial number unique for each request. This isn't where work gets done -- the handler is queued after this, and work is done when `handleRequest` is called.` close(self) `Close the socket. Called when the handler is finished. Closes the socket and returns the handler to the pool of inactive handlers.` endRequest(self, error=None) `Track end of a raw request. Subclasses can use and override this method.` startRequest(self, requestDict=None) `Track start of a raw request. Subclasses can use and override this method.` Data descriptors inherited from Handler: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class ServerShutDownError(ThreadAbortedError)
`` | `Server has been shut down error`
| Method resolution order: ServerShutDownError ThreadAbortedError WebKit.HTTPExceptions.HTTPServiceUnavailable WebKit.HTTPExceptions.HTTPException exceptions.Exception exceptions.BaseException __builtin__.object Methods inherited from WebKit.HTTPExceptions.HTTPException: __str__(self) code(self) `The integer code.` codeMessage(self) `The message (like ``Not Found``) that goes with the code.` description(self) `Error description. Possibly a plain text version of the error description, though usually just identical to `htDescription`.` headers(self) `Get headers. Additional headers that should be sent with the response, not including the Status header. For instance, the redirect exception adds a Location header.` htBody(self) `The HTML body of the page.` htDescription(self) `HTML error description. The HTML description of the error, for presentation to the browser user.` htTitle(self) `The title, but it may include HTML markup (like italics).` html(self) `The error page. The HTML page that should be sent with the error, usually a description of the problem.` setTransaction(self, trans) `Set transaction. When the exception is caught by `Application`, it tells the exception what the transaction is. This way you can resolve relative paths, or otherwise act in a manner sensitive of the context of the error.` title(self) `The title used in the HTML page.` Data descriptors inherited from WebKit.HTTPExceptions.HTTPException: __weakref__ `list of weak references to the object (if defined)` Methods inherited from exceptions.Exception: __init__(...) `x.__init__(...) initializes x; see help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `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__(...) __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message
class TASStreamOut(WebKit.ASStreamOut.ASStreamOut)
`` | `Response stream for ThreadedAppServer. The `TASStreamOut` class streams to a given socket, so that when `flush` is called and the buffer is ready to be written, it sends the data from the buffer out on the socket. This is the response stream used for requests generated by ThreadedAppServer.`
| Method resolution order: TASStreamOut WebKit.ASStreamOut.ASStreamOut __builtin__.object Methods defined here: __init__(self, sock, autoCommit=False, bufferSize=8192) `Create stream. We get an extra `sock` argument, which is the socket which we'll stream output to (if we're streaming).` flush(self) `Flush stream. Calls `ASStreamOut.ASStreamOut.flush`, and if that returns True (indicating the buffer is full enough) then we send data from the buffer out on the socket.` Data and other attributes defined here: e = 'ECONNRESET' Methods inherited from WebKit.ASStreamOut.ASStreamOut: autoCommit(self) `Get the auto commit mode.` buffer(self) `Return accumulated data which has not yet been flushed. We want to be able to get at this data without having to call flush first, so that we can (for example) integrate automatic HTML validation.` bufferSize(self) `Get the buffer size.` clear(self) `Try to clear any accumulated response data. Will fail if the response is already sommitted.` close(self) `Close this buffer. No more data may be sent.` closed(self) `Check whether we are closed to new data.` commit(self, autoCommit=True) `Called by the Response to tell us to go. If `_autoCommit` is True, then we will be placed into autoCommit mode.` committed(self) `Are we committed?` needCommit(self) `Request for commitment. Called by the `HTTPResponse` instance that is using this instance to ask if the response needs to be prepared to be delivered. The response should then commit its headers, etc.` pop(self, count) `Remove count bytes from the front of the buffer.` prepend(self, charstr) `Add the attached string to front of the response buffer. Invalid if we are already committed.` setAutoCommit(self, autoCommit=True) `Set the auto commit mode.` setBufferSize(self, bufferSize=8192) `Set the buffer size.` size(self) `Return the current size of the data held here.` write(self, charstr) `Write a string to the buffer.` Data descriptors inherited from WebKit.ASStreamOut.ASStreamOut: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class ThreadAbortedError(WebKit.HTTPExceptions.HTTPServiceUnavailable)
`` | `Thread aborted error`
| Method resolution order: ThreadAbortedError WebKit.HTTPExceptions.HTTPServiceUnavailable WebKit.HTTPExceptions.HTTPException exceptions.Exception exceptions.BaseException __builtin__.object Methods inherited from WebKit.HTTPExceptions.HTTPException: __str__(self) code(self) `The integer code.` codeMessage(self) `The message (like ``Not Found``) that goes with the code.` description(self) `Error description. Possibly a plain text version of the error description, though usually just identical to `htDescription`.` headers(self) `Get headers. Additional headers that should be sent with the response, not including the Status header. For instance, the redirect exception adds a Location header.` htBody(self) `The HTML body of the page.` htDescription(self) `HTML error description. The HTML description of the error, for presentation to the browser user.` htTitle(self) `The title, but it may include HTML markup (like italics).` html(self) `The error page. The HTML page that should be sent with the error, usually a description of the problem.` setTransaction(self, trans) `Set transaction. When the exception is caught by `Application`, it tells the exception what the transaction is. This way you can resolve relative paths, or otherwise act in a manner sensitive of the context of the error.` title(self) `The title used in the HTML page.` Data descriptors inherited from WebKit.HTTPExceptions.HTTPException: __weakref__ `list of weak references to the object (if defined)` Methods inherited from exceptions.Exception: __init__(...) `x.__init__(...) initializes x; see help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `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__(...) __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message
class ThreadedAppServer(WebKit.AutoReloadingAppServer.AutoReloadingAppServer)
`` | `Threaded Application Server. `ThreadedAppServer` accepts incoming socket requests, spawns a new thread or reuses an existing one, then dispatches the request to the appropriate handler (e.g., an Adapter handler, HTTP handler, etc., one for each protocol). The transaction is connected directly to the socket, so that the response is sent directly (if streaming is used, like if you call `response.flush()`). Thus the ThreadedAppServer packages the socket/response, rather than value being returned up the call chain.`
| Method resolution order: ThreadedAppServer WebKit.AutoReloadingAppServer.AutoReloadingAppServer WebKit.AppServer.AppServer WebKit.ConfigurableForServerSidePath.ConfigurableForServerSidePath MiscUtils.Configurable.Configurable __builtin__.object Methods defined here: __init__(self, path=None) `Setup the AppServer. Create an initial thread pool (threads created with `spawnThread`), and the request queue, record the PID in a file, and add any enabled handlers (Adapter, HTTP, Monitor).` abortLongRequests(self) `Check for long-running requests and cancel these. The longest allowed execution time for requests is controlled by the MaxRequestTime setting.` abortRequest(self, requestID, exception=<class 'WebKit.ThreadedAppServer.RequestAbortedError'>) `Abort a request by raising an exception in its worker thread. A return value of one means the thread was successfully aborted, a value of zero means the thread could not be found, any other value indicates that an error has occurred.` 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) mainloop(self, timeout=1) `Main thread loop. This is the main thread loop that accepts and dispatches socket requests. It goes through a loop as long as ``self._running > 2``. Setting ``self._running = 2`` asks the the main loop to end. When the main loop is finished, it sets ``self._running = 1``. When the AppServer is completely down, it sets ``self._running = 0``. The loop waits for connections, then based on the connecting port it initiates the proper Handler (e.g., AdapterHandler, HTTPHandler). Handlers are reused when possible. The initiated handlers are put into a queue, and worker threads poll that queue to look for requests that need to be handled (worker threads use `threadloop`). Every so often (every 5 loops) it updates thread usage information (`updateThreadUsage`), and every ``MaxServerThreads * 2`` loops it it will manage threads (killing or spawning new ones, in `manageThreadCount`).` 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`.` Data and other attributes defined here: e = 'EPROTO' 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) `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.` Static methods inherited from WebKit.AutoReloadingAppServer.AutoReloadingAppServer: restart() `Do the actual restart. Call `shouldRestart` from outside the class.` 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.` createApplication(self) `Create and return an application object. Invoked by __init__.` 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'>) `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'>) `Return setting, using the server side path when indicated. 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 destination 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().` Data descriptors inherited from MiscUtils.Configurable.Configurable: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class WorkerThread(threading.Thread)
`` | `Base class for Webware worker threads that can be aborted. (Idea taken from: http://sebulba.wikispaces.com/recipe+thread2)`
| Method resolution order: WorkerThread threading.Thread threading._Verbose __builtin__.object Methods defined here: abort(self, exception=<class 'WebKit.ThreadedAppServer.ThreadAbortedError'>) `Abort the current thread by raising an exception in its context. A return value of one means the thread was successfully aborted, a value of zero means the thread could not be found, any other value indicates that an error has occurred.` threadID(self) `Return the thread's internal id.` Methods inherited from threading.Thread: __init__(self, group=None, target=None, name=None, args=(), kwargs=None, verbose=None) `This constructor should always be called with keyword arguments. Arguments are: *group* should be None; reserved for future extension when a ThreadGroup class is implemented. *target* is the callable object to be invoked by the run() method. Defaults to None, meaning nothing is called. *name* is the thread name. By default, a unique name is constructed of the form "Thread-N" where N is a small decimal number. *args* is the argument tuple for the target invocation. Defaults to (). *kwargs* is a dictionary of keyword arguments for the target invocation. Defaults to {}. If a subclass overrides the constructor, it must make sure to invoke the base class constructor (Thread.__init__()) before doing anything else to the thread.` __repr__(self) getName(self) isAlive(self) `Return whether the thread is alive. This method returns True just before the run() method starts until just after the run() method terminates. The module function enumerate() returns a list of all alive threads.` isDaemon(self) is_alive = isAlive(self) `Return whether the thread is alive. This method returns True just before the run() method starts until just after the run() method terminates. The module function enumerate() returns a list of all alive threads.` join(self, timeout=None) `Wait until the thread terminates. This blocks the calling thread until the thread whose join() method is called terminates -- either normally or through an unhandled exception or until the optional timeout occurs. When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof). As join() always returns None, you must call isAlive() after join() to decide whether a timeout happened -- if the thread is still alive, the join() call timed out. When the timeout argument is not present or None, the operation will block until the thread terminates. A thread can be join()ed many times. join() raises a RuntimeError if an attempt is made to join the current thread as that would cause a deadlock. It is also an error to join() a thread before it has been started and attempts to do so raises the same exception.` run(self) `Method representing the thread's activity. You may override this method in a subclass. The standard run() method invokes the callable object passed to the object's constructor as the target argument, if any, with sequential and keyword arguments taken from the args and kwargs arguments, respectively.` setDaemon(self, daemonic) setName(self, name) start(self) `Start the thread's activity. It must be called at most once per thread object. It arranges for the object's run() method to be invoked in a separate thread of control. This method will raise a RuntimeError if called more than once on the same thread object.` Data descriptors inherited from threading.Thread: daemon `A boolean value indicating whether this thread is a daemon thread (True) or not (False). This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False. The entire Python program exits when no alive non-daemon threads are left.` ident `Thread identifier of this thread or None if it has not been started. This is a nonzero integer. See the thread.get_ident() function. Thread identifiers may be recycled when a thread exits and another thread is created. The identifier is available even after the thread has exited.` name `A string used for identification purposes only. It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor.` Data descriptors inherited from threading._Verbose: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`

Functions
`` |  | chdir(path, force=False) `Execute os.chdir() with safety provision.` currentFrames = _current_frames(...) `_current_frames() -> dictionary Return a dictionary mapping each current thread T's thread id to T's current stack frame. This function should be used for specialized purposes only.` dumps(...) `dumps(value[, version]) Return the string that would be written to a file by dump(value, file). The value must be a supported type. Raise a ValueError exception if value has (or contains an object that has) an unsupported type. New in version 2.4: The version argument indicates the data format that dumps should use.` loads(...) `loads(string) Convert the string to a value. If no valid value is found, raise EOFError, ValueError or TypeError. Extra characters in the string are ignored.` localtime(...) `localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min, tm_sec,tm_wday,tm_yday,tm_isdst) Convert seconds since the Epoch to a time tuple expressing local time. When 'seconds' is not passed in, convert the current time instead.` main(args) `Command line interface. Run by `Launch`, this is the main entrance and command-line interface for ThreadedAppServer.` run(workDir=None) `Start the server (`ThreadedAppServer`). `workDir` is the server-side path for the server, which may not be the ``Webware/WebKit`` directory (though by default it is). After setting up the ThreadedAppServer we call `ThreadedAppServer.mainloop` to start the server main loop. It also catches exceptions as a last resort.` runMainLoopInThread() `# Determines whether the main look should run in another thread. # On Win NT/2K/XP, we run the mainloop in a different thread because # it's not safe for Ctrl-C to be caught while manipulating the queues. # It's not safe on Linux either, but there, it appears that Ctrl-C will # trigger an exception in ANY thread, so this fix doesn't help.` setCloseOnExecFlag(fd) `Set flag for file descriptor not to be inherited by child processes.` shutDown(signum, frame) `Signal handler for shutting down the server.` sleep(...) `sleep(seconds) Delay execution for a given number of seconds. The argument may be a floating point number for subsecond precision.` threadDump(signum, frame) `Signal handler for dumping thread stack frames to stdout.` time(...) `time() -> floating point number Return the current time in seconds since the Epoch. Fractions of a second may be present if the system clock provides them.`

Data
`` |  | FD_CLOEXEC = 1 F_GETFD = 2 F_SETFD = 2 PyThreadState_SetAsyncExc = <_FuncPtr object> SIGBREAK = None SIGHUP = 1 SIGINT = 2 SIGQUIT = 3 SIGTERM = 15 debug = False defaultConfig = {'AdapterPort': 8086, 'AddressFiles': '%s.address', 'EnableAdapter': True, 'EnableHTTP': True, 'EnableMonitor': False, 'EnableSCGI': False, 'HTTPPort': 8080, 'Host': 'localhost', 'MaxRequestTime': 300, 'MaxServerThreads': 20, ...} doesRunHandleExceptions = True exitStatus = 0 intLength = 5 pythonapi = <PyDLL 'None', handle 2816b000 at 292796ac> server = None settingRE = <_sre.SRE_Pattern object> usage = '\nThreadedAppServer takes the following command l...ettingName=value: change configuration settings\n\n'