Free dispatcher software for linux

Content Dispatcher project will dispatch content over many plone sites in one click.

Let a content to be dispatch over many plone sites in one click.

XML::Filter::Dispatcher is a path based event dispatching with DOM support.

SYNOPSIS

use XML::Filter::Dispatcher qw( :all );

my $f = XML::Filter::Dispatcher->new(
Rules => [
foo => &handle_foo_start_tag,
@bar => &handle_bar_attr,

## Send any elts and their contents to $handler
snarf//self::node() => $handler,

## Print the text of all elements
description
=> [ string() => sub { push @out, xvalue } ],
],

Vars => {
"id" => [ string => "12a" ],
},
);

WARNING: Beta code alert.

A SAX2 filter that dispatches SAX events based on "EventPath" patterns as the SAX events arrive. The SAX events are not buffered or converted to an in-memory document representation like a DOM tree. This provides for low lag operation because the actions associated with each pattern are executed as soon as possible, usually in an elements start_element() event method.

This differs from traditional XML pattern matching tools like XPath and XSLT (which is XPath-based) which require the entire document to be built in memory (as a "DOM tree") before queries can be executed. In SAX terms, this means that they have to build a DOM tree from SAX events and delay pattern matching until the end_document() event method is called.

XML::Filter::Dispatcher::AsStructHandler Perl module can help you convert SAX stream in to simple, data-oriented structure.

SYNOPSIS

## Ordinarily used via the XML::Filter::Dispatchers as_data_struct()
## built-in extension function for XPath

This SAX2 handler builds a simple hash from XML. Text from each element and attribute is stored in the hash with a key of a relative path from the root down to the current element.

The goal is to produce a usable structure as simply and quickly as possible; use XML::Simple for more sophisticated applications.

The resulting data structure has one hash per element, one scalar per attribute, and one scalar per text string in each leaf element.

Warnings are emitted if any content other than whitespace is discarded.

The root element name is discarded.

If you are using namespaces, you must pass in the Namespaces option, otherwise not. Using namespaces without a Namespaces option or vice versa will not work.

Only start_document(), start_element(), characters(), end_element(), and end_document() are provided; so all comments, processing instructions etc., are discarded.

Log::Dispatch::ToTk provides class to redirect Log::Dispatch to Tk widgets.

Most users will only need to use Log::Dispatch::TkText widget to have Log::Dispatch messages written on a text widget.

For more fancy uses, this module can be used by a composite widget dedicated to handle Log::Dispatch logs.

This module is the interface class between Log::Dispatch and Tk widgets. This class is derived from Log::Dispatch::Output.

One ToTk object will be created for each Log::Dispatch::Tk* widget and the user must register the ToTk object to the log dispatcher.

Create a new ToTk object. Parameter are :
- widget ($) - The buddy widget object
- name ($) - The name of the object (not the filename!). Required.
- min_level ($) - The minimum logging level this object will accept. See the Log::Dispatch documentation for more information. Required.
- max_level ($) - The maximum logging level this obejct will accept. See the Log::Dispatch documentation for more information. This is not required. By default the maximum is the highest possible level (which means functionally that the object has no maximum).

speechd-el is an Emacs client to Speech Dispatcher, BrlTTY, and other alternative output devices.
speechd-el provides a complex speech/Braille interface to Emacs, and is focused especially on (but not limited to) blind and visually impaired users.
It allows the user to work with Emacs without looking on the screen, using the speech and Braille output.
Enhancements:
- The output mechanism was modularized and redesigned to support multiple output devices.
- The most important impact of this change is BrlTTY support, which works in a way similar to how speech output works.
- This means that speechd-el can be used with both Speech Dispatcher and BrlTTY now.

Apache2::JSONRPC is a mod_perl handler for JSONRPC.

SYNOPSIS

< Location /json-rpc >
SetHandler perl-script
PerlOptions +GlobalRequest
PerlResponseHandler Apache2::JSONRPC->handler
JSONRPC_Class CGI::JSONRPC::Dispatcher
< /Location >

Apache2::JSONRPC is a subclass of CGI::JSONRPC that provides some extra bells and whistles in a mod_perl2 environment.
Currently, the main feature is the "JSONRPC_Class" apache2 config directive, which allows you to define what class to use for invoking JSONRPC methods. The default is the same as CGI::JSONRPC uses, CGI::JSONRPC::Dispatcher.

Alamin GSM SMS Gateway provides a SMS-to-SMSQP/SMTP gateway and client to send SMS from an IP client.
Alamin GSM SMS Gateway is a gateway for exchanging messages between GSM and IP networks.
The main objective of the gateway is to provide a reliable delivery service and conversion in both directions in order to extend to the GSM network the functions of IP-based applications.
To make an analogy, its like a web server for HTML pages. They need the web server and provide it with content. The Alamin Gateway paves the way for all types of mobile applications on GSM using SMS messages. One very common use for the gateway is to send an alarm from a computer network to its system administrators. Another is the currently common apps showing tv viewers comments on tv programs.
Currently, the connection to the gateway from the IP network can be achieved using SMSQP (11201), the native protocol of the gateway for sending messages and managing the queue. The SMSQP protocol can be used directly or through the "gsgc" client. Implementing a SMTP interface is easy configuring your MTA for calling a script that prepares the message and calls "gsgc".
The connection between the gateway and the GSM network can be realized through a GSM modem or through a telephone supported by the project Gnokii. A SMPP connector is being developed these days.
At present, only GSM modems can be used in "text" mode. In the future, "pdu" mode will also be supported. Not all devices support both modes, so that you will have to read the manual of your mobile telephone or GSM modem and consult the GSM devices page.
Alamin is developed on Debian GNU/Linux but runs almost in all perl enabled systems.
Enhancements:
- smtp interface has been removed, it was buggy and not fully implemented.
- SMPP interface for sending and receiving messages, both connectors are in own daemons, outside the core module and the message dispatcher.
- SMPP interface uses the Net::SMPP perl module.
- It has been tested onlywith mblox servers.
- MySQL interface for inserting records from received messages and send messages in a table.
- New config files are in perl script format.

XML::Filter::Tee can send SAX events to multiple processor, with switching.

SYNOPSIS

my $t = XML::Filter::Tee->new(
{ Handler => $h0 },
{ Handler => $h1 },
{ Handler => $h2 },
...
);

## Altering the handlers list:
$t->set_handlers( $h0, $h1, $h2, $h3 );

## Controlling flow to a handler by number and by reference:
$t->disable_handler( 0 );
$t->enable_handler( 0 );

$t->disable_handler( $h0 );
$t->enable_handler( $h0 );

## Use in a SAX machine (though see L and
## L for a more convenient way to build a machine
## like this):
my $m = Machine(
[ Intake => "XML::Filter::Tee" => qw( A B ) ],
[ A => ">>log.xml" ],
[ B => *OUTPUT ],
);

XML::Filter::Tee is a SAX filter that passes each event it receives on to a list of downstream handlers.

Its like XML::Filter::SAXT in that the events are not buffered; each event is sent first to the tap, and then to the branch (this is different from XML::SAX::Dispatcher, which buffers the events). Unlike XML::Filter::SAXT, it allows its list of handlers to be reconfigured (via "set_handlers") and it allows control over which handlers are allowed to receive events. These features are designed to make XML::Filter::Tee instances more useful with SAX machines, but they to add some overhead relative to XML::Filter::SAXT.

The events are not copied, since they may be data structures that are difficult or impossibly to copy properly, like parts of a C-based DOM implementation. This means that the handlers must not alter the events or later handlers will see the alterations.