Free dispatch 0.0.2a software for linux

dispatch is a multi-tier architecture object-oriented framework that allows access to methods and variables at the command line and in shell scripts or via a GUI.
The project is in an early stage and you will probably not be able to compile it easily or use it for significant work.
There are lots of things which are not documented yet, as they only work occasionally. As the current written code is only a framework, no real application of it yet exists, there are still much things to invent. Get involved.
This software package represents a meta program used to manage unix programs. It is a class library in the domain of system administration. It is similar to Microsoft .NET or corba or Unix as it is language independent. Indeed, a method can be written in any language, because the interface of a method is the same as that of a unix command.
That means a method is passed an array of arguments, it has a standard input, standard output and standard error channel and returns a small integer exit code. The difference to a shell script is that there is no actual execve system call involved in calling a method, but the method is in a shared object that can be linked dynamically into the running process.
With interpreted languages like perl, first the interpreter is dynamically linked into the current process which in turn executes the method written in the target language. That means that the second call of a certain method only involves some lookup in internal data structures to find the already loaded (c++, perl) and byte-compiled (perl) implementation.
But this is only half of the story. The power of object orientation to a certain degree comes from the fact that you have abstract interfaces and concrete implementations which are interchangeable to a certain extend. This fact is still true of course, when you map the OO paradigm to the Unix shell and the domain of system management.
But unfortunately this principle was not honored by the software that exists on posix compatible systems so far. An example of an interface relating to system management and configuration is internet server software configuration.
There a many ways to configure on which port a piece of software should listen. In apache, you write Listen or BindAddress, the tcpserver from ucspi-tcp expects a command line argument, the inetd superserver expects it as the first column of a table in a free-form textfile.
It is therefore impossible to know where an arbitrary server listens if you do not write specialized parser code for every configuration file format in existence. It would be so much easier to have an interface that has a method called port that you can call to either query the port or set it. Then you can call the exact same method on any server that implements the interface and dont have to care about syntax rules.
Enhancements:
- Examples added

Log::Dispatch::Atom is a Perl module to log to an atom feed.

SYNOPSIS

use Log::Dispatch::Atom;

my $log = Log::Dispatch::Atom->new(
name => foo,
min_level => debug,
file => file.atom
);
$log->log_message( level => error, message => A problem happened );
$log->log_message( level => debug, message => Got Here );

This class implements logging backed by an Atom feed so that you can subscribe to the errors produced by your application.

You should not use this object directly, but should manage it via a Log::Dispatch object.

IMPLEMENTATION NOTES

In order to safely write to the log file, the entire file must be locked each time that an entry is logged. This probably makes it unsuitable for high volume log files.
The log file is opened and closed on each call to log_message().

METHODS

new()

Takes a hash of arguments. Returns a new Log::Dispatch::Atom object. The following parameters are used:

name [mandatory]

The name of the logging object.

min_level [mandatory]

The minimum logging level this object will accept. See Log::Dispatch for more information.

max_level [optional]

The maximum logging level this object will accept. See Log::Dispatch for more information. The default is the highest possible level (ie: no maximum).

file [mandatory]

Specifies the location of the file to read/write the feed from.

feed_id [optional]

Specifies the identity of the feed itself. Normally, this should be set to the published URI of the feed.
If not specified, it will be omitted, which is in violation of the Atom specification. For more information, see http://www.atomenabled.org/developers/syndication/#requiredFeedElements.

feed_title [optional]

The title of the feed. This should probably be set to the name of your application.

If not specified, it will be omitted, which is in violation of the Atom specification. For more information, see http://www.atomenabled.org/developers/syndication/#requiredFeedElements.
XXX This should probably just use the name parameter. What do you think? Let me know.

feed_author [optional]

The author details of a feed. This is specified as a hash reference, which must contain one or more of the three keys name, email and uri.

In order to create a valid Atom feed, you must either supply an author in every single entry (log message), or ensure that the feed itself has an author. The latter is probably the easier solution, so I recommend this parameter be supplied.

NB: The feed_* parameters will only be used when a new feed is being created. If you are creating a new object for an existing feed, they will be ignored.

log_message()

Takes a hash of arguments. Has no return value. The following parameters are used.

message [mandatory]

The actual log message.

level [mandatory]

The level of the message. See Log::Dispatch for a full list.

id [optional]

Each entry requires an id in order for the feed as a whole to be a valid Atom document. Its used by readers of Atom documents to determine whether or not an entry has been seen previously.

If not specified, this will default to an URL comprising the current time plus the pid plus the hostname plus a monotonically increasing integer. eg: tag:fred.example.com,2005-12-07:1133946771/20827/2. This should be good enough for a uniqueness test.

author [optional]

You can specify author details for an individual entry if desired. The author parameter is expected to be a hash reference, which must contain one or more of the keys name, email or uri.

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.

The port scan plug in for snort, or just portscan for short is intended to be used in conjunction with snort and logcheck. The tool will allow you to monitor your snort log file and then do port scans based upon certain keywords.

This program requires nmap and snort. If you want it to run automatically you will also need logcheck. Hopefully in the future this program will be built to run as a daemon and will no longer rely on logcheck. But for now use logcheck.

Make sure that Snort is set to log to syslog and that you know which syslog file it is logging to. The contents of the file will look like this :

Jul 6 18:34:00 thqms3 snort: IDS126/x11_Outgoing_Xterm: 212.30.119.109:6000 -> 63.80.88.42:33248

To install first run install.sh

After running install.sh you may edit the portscan.conf file in /etc/portscan and the keywords file. After making any necassary changes you will need to add the following lines into your logcheck.sh file

/usr/sbin/portscan.pl &
cat $TMPDIR/checkoutput.$$ > $TMPDIR/portscan.log

So your logcheck.sh file should now look like this (toward the bottom)

Log::Dispatch::TkText provides a Text widget for Log::Dispatch.

SYNOPSIS

use Tk ;
use Log::Dispatch;
use Log::Dispatch::TkText ;

my $dispatch = Log::Dispatch->new;

my $mw = MainWindow-> new ;

my $tklog = $mw->Scrolled(LogText, name => tk,
min_level => debug);
$tklog -> pack ;

# add the logger object to $dispatch (not the widget !!)
$dispatch->add($tklog->logger) ;

$dispatch -> log
(
level => info,
message => "Quaquacomekiki ? (so says Averell Dalton)"
) ;

This widget provide a read-only text widget (based on Tk::ROText) for logging through the Log::Dispatch module.

Note that this widget works with a buddy Log::Dispatch::ToTk object which will be created by the widgets constructor. The reference to this buddy object must be added to the main log dispatcher.

Dispatch Software is a software that saves time, money and increase your customer satisfaction. 100% free online, web-based dispatch software makes it easy to keep track of your vehicles.
Easily view what each vehicle will be doing each day. Export the daily schedule to a printable spreadsheet file for your driver to take on the road. View all units on one page for faster scheduling.
Dispatch drivers can view schedules ahead of time for better planning and time management.
Installation:
-copy all files to your web host
-use phpmyadmin or your mysql interface to run site.sql against your database.
-open site.xml and edit the database section with your database details.
-go to index.php and login with username of admin with a password of test.
-be sure to change the passwords for the admin and regular user.
Setup the site.xml file with your database settings as follows.
< database type="mysql" >
< server >database server address< /server >
< login >database login< /login >
< password >database password< /password >
< default >mysql database name< /default >
< /database >
Add this to your .htaccess file to prevent viewing of the xml config file.
< Files ~ ".xml" >
Order allow,deny
Deny from all
Satisfy All
< /Files >
Enhancements:
- A bug in the main library file for the dispatching system was fixed.

Sub::PatMat can call a version of subroutine depending on its arguments.
SYNOPSIS
use Sub::PatMat;
# basics:
sub fact : when($_[0] $b) { 1 }
print join ", ", sort mysort (3,1,2);
# intuiting parameter names:
sub dispatch : when($ev eq "help") { my ($ev) = @_; print "helpn" }
sub dispatch : when($ev eq "blah") { my ($ev) = @_; print "blahn" }
dispatch("help");
dispatch("blah");
# no fallback, this will die:
dispatch("hest"); # dies with "Bad match"
# silly
sub do_something : when(full_moon()) { do_one_thing() }
sub do_something { do_something_else() }
The Sub::PatMat module provides the programmer with the ability to define a subroutine multiple times and to specify what version of the subroutine should be called, depending on the parameters passed to it (or any other condition).
This is somewhat similar to argument pattern matching facility provided by many programming languages.
To use argument pattern matching on a sub, the programmer has to specify the when attribute. The parameter to the attribute must be a single Perl expression.
When the sub is called, those expressions are evaluated consequitively until one of them evaluates to a true value. When this happens, the corresponding version of a sub is called.
If none of the expressions evaluates to a true value, a Bad Match exception is thrown.
It is possible to specify a fall-back version of the function by doing one of the following:
specifying when without an expression
specifying when with an empty expression
not specifying the when attribute at all
Please note that it does not make sense to specify any non-fall-back version of the sub after the fall-back version, since such will never be called.
There is an additional limitation for the last form of the fall-back version (the one without the when attribute at all), namely, it must be the last version of the sub defined.
It is possible to specify named sub parameters in the when-expression. This facility is highly experimental and is currently limited to scalar parameters only. The named sub parameters are extracted from expressions of the form
my (parameter list) = @_;
anywhere in the body of the sub.
Version restrictions:
- The ability to intuit parameter names is very limited and without doubts buggy.
- The when attribute condition is limited to a single Perl expression.
Enhancements:
- Perl

Boost Channel is a C++ template framework for distributed message passing and event dispatching. Its major components (message IDs, routing algorithms...) are highly configurable as template parameters.
As a namespace shared by peer threads, channels support publish/subscribe scope control, message filtering, and translation.
Enhancements:
- Jamfile.v2 was added for building the channel library and examples (the current boost CVS build system was changed so Jamfile.v2 is required).
- However, there are issues with building samples using Jamfile.v2 with WindowsXP and VC++.
- Windows users should use the existing Jamfile (v1).
- This may involve replacing the boost/tools/build/v1 directory with the content from an older boost release or CVS checkout (such as 12/10/2006).