Free message queue software for linux

Putmail Queue provides a queuing system for putmail.py from the Putmail project.

It allows you to compose your email messages offline, keep them in a queue, and send them all together later.

This is my first try at providing a queuing system for putmail.py. Inside, youll find two programs: putmail_enqueue.py and putmail_dequeue.py.

To use them, you must first create the directory $HOME/.putmail/queue/. Its recommended that only you have access to it.

Install the program by running install.sh as root if necessary. Optionally, edit the file first to specify destination directories.

Usage instructions are in the man page. Use "man putmail-queue" to read it. It is a recommended one-time read.

X Message Daemon is used to overlay graphical information messages on your X display.

You can choose parameters such as color, font, icon, and duration.

It also has a frontend Perl daemon and client.

Installing:

# ./configure
# make
# make install

then edit /usr/local/share/Xmsgd/etc/msgmaild.conf and change the configuration to your preferences.

Basic Usage:

- tailing your /var/log/messages :
# tail -f /var/log/messages | msgclient.pl &

Debug::Message is a Perl module that eases the use of debug print with level, indentation and color.

SYNOPSIS

use Debug::Message;
use Log::Dispatch;
use Log::Dispatch::Screen;

my $dispatcher = Log::Dispatch->new;
$dispatcher->add( Log::Dispatch::Screen->new( name => screen,
min_level => 0 ));

my $info = Debug::Message->new(1);
$info->add_dispatcher($dispatcher);
$info->print("print");
$info->yellow("warn");
$info->red("err");
$info->printcn("error message", bold red);

my $critical = Debug::Message->new(5);
$critical->add_dispatcher($dispatcher);
$critical->redn("err");
For disabling the debugging simply do not attach any dispatchers.
$critical->disable; # Will detach the attached backend

There was no module for simple debug messages supporting debug/verbosity levels and indentation. So this is the one, that is supposed to take this place.
This module is an art of frontend to Log::Dispatch as Log::Dispatch itself supports levels, but no colors and the functions calling is tedious.

There are some methods defined. Each outputs a different color, optionally it can add a newline after the messaage. They dispatch the messages to all added dispatchers, but generaly only one will be needed as the Log::Dispatch itself can have more backends.

Parallel::Queue is a Perl module to fork or thread a list of closures N-way parallel.

SYNOPSIS

# example queue:
# only squish files larger than 8KB in size. figure
# that the system can handle four copies of squish
# running at the same time without them interfering
# with one another.

my @queue = map { -s > 8192 ? sub{ squish $_ } : () } @filz;

# functional: pass in the count and list of coderefs.
#
# adding runqueue exports the subroutine into
# the current package. useful for non-OO situations.
#
# run the queue 4 way parallel.

use Parallel::Queue qw( runqueue verbose fork );

my @remaining = runqueue 4, @queue;

die "Incomplete jobs" if @remaining;

# OO: generate queue manager and use without the
# runqueue arguments, construct a queue manager,
# and use it to run the jobs

use Parallel::Queue;

my $quemgr = Parallel::Queue->construct( thread );

$quemgr->runqueue( 4, @queue );

die "Incomplete jobs" if @queue;

# call Parallel::Queue with the default configuration
# (fork quietly).

require Parallel::Queue;

Parallel::Queue->runqueue( 4, @queue );

# pre-define defaults for the objects: leave
# out runqueue, set the rest, and construct
# an object. the one here gets verbose, thread,
# and debug all set to true.

use Parallel::Queue qw( verbose thread );

my $quemgr = Parallel::Queue->construct( debug );

my @remaining = $quemgr->runqueue( 4, @queue );

Given a count and an array of coderefs (most likely closures), runqueue will run the jobs in parallel. The jobs can be run via fork or detached threads [see known issues for threading]. Jobs on the queue are executed until one of them exits non-zero, the fork/thread operation fails, or all of them are dispatched (i.e., the queue is empty).

Mail::Message::Field contains one line of a message header.

INHERITANCE

Mail::Message::Field
is a Mail::Reporter

Mail::Message::Field is extended by
Mail::Message::Field::Fast
Mail::Message::Field::Flex
Mail::Message::Field::Full

SYNOPSIS

my $field = Mail::Message::Field->new(From => fish@tux.aq);
print $field->name;
print $field->body;
print $field->comment;
print $field->content; # body & comment
$field->print(*OUT);
print $field->string;
print "$fieldn";
print $field->attribute(charset) || us-ascii;

This implementation follows the guidelines of rfc2822 as close as possible, and may there produce a different output than implementations based on the obsolete rfc822. However, the old output will still be accepted.

These objects each store one header line, and facilitates access routines to the information hidden in it. Also, you may want to have a look at the added methods of a message:

my @from = $message->from;
my $sender = $message->sender;
my $subject = $message->subject;
my $msgid = $message->messageId;

my @to = $message->to;
my @cc = $message->cc;
my @bcc = $message->bcc;
my @dest = $message->destinations;

my $other = $message->get(Reply-To);

pytimeago is a human-oriented representation of time deltas, a Python library.

First, I shall define what time delta is. Since Δ generally means “difference”, we take time delta to stand for difference between two events in time. Quite common, however, is to have the current time for the second event. In pytimeago we deal with time deltas from such a perspective.

Quite possibly, you can make use of this library if your application displays some dynamically generated items to the user, and you are looking for a good way to present information on how long ago specific item was created/processed/whatever.

Below is small code snippet demonstrating how simple it is to embed pytimeago:

from pytimeago.english import english
from time import time, sleep

message = queue.getNextMessage()
delta = time() - message.arrived_time
print "Message arrived %s" % english(delta)

Prints, e.g.
Message arrived 15mins ago

As you see, pytimeago is package, and has individual modules for every language supported. As of 2006-08-13 the only supported language is English. However, you can take a look at rather trivial implementation of English engine, write one for your language, and send it to to me (email at the bottom of page).

Every language should come with a set of doctests (I prefer them to casual unit tests), just like the English version does. Dont be too verbose, but check essential cases.

Mail::Message::Head::Complete is a Perl module with the header of one message.

INHERITANCE

Mail::Message::Head::Complete
is a Mail::Message::Head
is a Mail::Reporter

Mail::Message::Head::Complete is extended by
Mail::Message::Head::Partial
Mail::Message::Replace::MailHeader

Mail::Message::Head::Complete is realized by
Mail::Message::Head::Delayed
Mail::Message::Head::Subset

SYNOPSIS

my $head = Mail::Message::Head::Complete->new;
See Mail::Message::Head

E-mails message can be in various states: unread, partially read, and fully read. The class stores a message of which all header lines are known for sure.

Orion Secure Message Gateway (OrionSMG) is a secure message gateway for transporting ebXML, SOAP, and custom message formats. It complies with the OASIS ebXML 2.0 specification, and can act in both intermediary and processing MHS roles to provide end-to-end reliable messaging.
Orion Secure Message Gateway software runs natively on Linux, OS X, and Windows with ODBC/PostgreSQL database support.
Enhancements:
- OrionSvnInfo.h now in correct directory.
- Old documentation temporarily added.
- Minimal README.txt file added.