Stem 0.10 review

Stem project is a modular network application suite and toolkit

License: GPL (GNU General Public License) File size: 457K Developer: Stem Systems

0

Stem project is a modular network application suite and toolkit.

Its goal is to convert common network programming into simple configuration.

Its modules are designed to be easily connected together like tinker toys via configuration files.

It uses message passing and events to communicate between local or remote objects.

It comes with extensive documentation, a cookbook for creating new modules, and demonstration applications.

The demonstrations show how Stem's current set of modules can be configured into many interesting applications including inetd, chat, and log management.

Here are some key features of "Stem":
Simple and centralized configuration.
High level Object Oriented internal API.
Message based and event driven.
Many existing modules and classes.

What's New in This Release:
The version number has been bumped to 0.10 because of the large number
of changes and the major improvements in reliability and speed.

Renamed Stem::TtyMsg to Stem::Console. Now it doesn't need any
arguments to be initialized. A Stem envioronment variable can be set
which will disable it. All the configuration files and demo scripts
have been updated to use it. The old TtyMsg module has been deleted.

Added Stem::Test::Echo.pm and Stem::Load::Driver.pm. They support
benchmarking of basic message passing in multiple modes.

Stem::Msg now only accepts the string format of message
addresses. This speeds up message creation and simplifies message
handling and delivery.

Stem::Class now supports attribute type checking and
conversion. Supported types include boolean, list, hash, LoL (and
friends), object and handle.

Stem::Conf has better error reporting. The Cell name and class are now
printed with the error.

Added the reply_type field to messages. This is used to make simple
state machines with messages (used in the work sequencing system).

Stem::Portal has been improved and now use the Stem::Packet module to
handle its buffering.

Added Stem::Packet and Stem::Codec::*. These modules support
serializing (marshalling) Stem data for use in pipes and files. The
codec to be used can be selected in the configuration file. This is
now used in Stem::Portal and all worker mode operations. Current codec
include Perl (Data::Dumper/eval), YAML, and Storable.

Split Log.pm into Log.pm and Log/Entry.pm. Moved Stem::LogTail.pm to
Stem::Log::Tail.pm. Added Stem::Log::File which handles physical log
files including rotation and archiving.

Added Stem::Trace.pm which gives modules a simple way to inject log
entries during program execution. It allows for creation of customized
Trace functions which can have defaults and different calling styles.

Split Stem::Cell.pm into multiple files to make it easier to
maintain. These include Stem::Cell::Sequence.pm, Stem::Cell::Clone.pm,
Stem::Cell::Pipe.pm and Stem::Cell::Work.pm

Added the Stem::DBI module which is a Stem message based front end to
DBI. This Cell can be configured with the all the SQL needed for your
application which is shared by all the Cells that use it. It can be
run in its own Stem Hub (process) thereby providing non-blocking
access to the DB from other Hubs. A farm of these proxies can be
created and managed by a WorkQueue Cell which will support parallel DB
access from one or more Hubs.

Added work sequencing support in Stem::Cell. This allows any Cell to
call local or remote methods and to manage their flow control. This is
an interim version that will be superseded by a new mini-language that
will be easier to code and will support more complex flow
(e.g. if/else/while). This is a very powerful feature that simplifies
complex state operations to simple flow control statements.

Added the Stem::WorkQueue module which allows a set of work request
messages to be distributed to a set of worker Cells. Modified
Stem::Cell to support a cell to request a new work message.

Created worker mode where an object (or data structure) gets
sent to a Cell via a message. The Cell can then write the object to a
socket or process or crunch it. The Cell then gets back the object
(presumably modified) and sends it back to the originator of the work
request. This is done in Stem::Cell and used in Stem::Proc,
Stem::Sock::Msg and Stem::DBI.

Created worker ready mode where a Cell can send out a message stating
it can receive a work message. Typically this will go to a WorkQueue
Cell. This message is sent out when the Cell starts up or after it
completes a previous work request.

Added Stem::Boot.pm which will run a set of external programs and
monitor them. Their output can be logged and they can be
restarted. Other options (for each program) include setting the
initial directory and which host to run it on (via ssh if desired).
The set of programs and options are loaded via a configuration file
specific to this module.

Added Stem::Inject.pm which has one method which will connect to
a Stem Hub and send it a single message. Then it will read back a
single message and return its data. This is meant to be used in Perl
programs that are not Stem driven and want to communicate with Stem
cells.

Updated the Stem Cell cookbook with more examples. It now shows how to
create class and object cells and also how to create cloneable Cells.