Events
The low-level core of a Stem hub is an event-loop engine. This
engine provides support for the common events needed in a networking
system, including reading and writing, socket connection and
acceptance, and timers. The Stem::Event system provides a high-level
API to these services to the rest of the hub while it, in turn,
relies on a lower-level event system which is currently Event.pm,
which is available on CPAN. This design isolates the actual event
engine used from the cells which need its services. There are plans
to support other event engines including Perl/Tk, and creating one
that runs on NT/Win2K.
Stem::Event uses the standard Stem callback style which requires
parameters designating the object and method to call when an event
has been triggered. In typical Stem fashion, the method names have
useful defaults so a Stem::Event call is made with very few
parameters.
Read and write Stem events take a required object and filehandle as
parameters, and an optional timeout value. If the I/O is not
completed before the timeout occurs, the timeout method is called
instead of the normal I/O completion method. The connect and accept
events also require an object and the appropriate socket parameters.
The connect event can take an optional timeout which behaves
similarly to the read/write timeout. A timer event can be created
which will be triggered after a given delay and optionally repeated
at a specified interval. As you would expect in an event system,
multiple instances of all these events can be active at the same
time.
Most cells will never directly use the Stem::Event interface as there
are higher level cells that perform commonly needed services for
them. These include Stem::AsynchIO, Stem::Socket, and Stem::Cron.
However, this does not stop any cell from directly calling these if
it needs finer control over its events.