Submodules

Module: cogen

This is a library for network oriented, coroutine based programming. The interfaces and events/operations aim to mimic some of the regular thread and socket features.

cogen uses the enhanced generators in python 2.5. These generators are bidirectional: they allow to pass values in and out of the generator. The whole framework is based on this.

The generator yields a Operation instance and will receive the result from that yield when the operation is ready.

Roughly the cogen internals works like this:

+------------------------+
| @coroutine             |
| def foo():             |
|     ...                |             op.process(sched, coro)
|  +->result = yield op--|----------------+------------+
|  |  ...                |                |            |
+--|---------------------+    +---------------+  +---------------------+
   |                          | the operation |  | the operation can't |
  result = op.finalize()      | is ready      |  | complete right now  |
   |                          +------|--------+  +----------|----------+
  scheduler runs foo                 |                      |
   |                                 |                      |
  foo gets in the active             |                      |
  coroutines queue                   |                      |
   |                                 |                      |
   +----------------------<----------+                      |
   |                                                    depening on the op
  op.run()                                               +---------+
   |      socket is ready               add it in        |         |
   +-------------<------------  ......  the reactor   <--+         |
   |                         later                                 |
   +------<-------------------  ......  add it in some other     <-+
    some event decides                  queue for later run
    this op is ready


The scheduler basicaly does 3 things:
 - runs active (coroutine,operations) pairs (calls process on the op)
 - runs the reactor
 - checks for timeouts

The reactor basicaly does 2 things:
 - calls the system to check what descriptors are ready
 - runs the operations that have ready descriptors

The operation does most of the work (via the process, finalize, cleanup,
run methods):
 - adds itself in the reactor (if it's a socket operation)
 - adds itself in some structure to be activated later by some other event
 - adds itself and the coro in the scheduler's active coroutines queue

The coroutine decorator wrappes foo in a Coroutine class that does some
niceties like exception handling, getting the result from finalize() etc.

Modules

common

A module for quick importing the essential core stuff. (coroutine, Scheduler, events, sockets, priority)

core

This module holds the essential stuff.

web

This module holds a wsgi server and future web-related code.