| |
- WebKit.ASStreamOut.ASStreamOut(__builtin__.object)
-
- TASStreamOut
- 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 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 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 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)
| |