Free queue repair software for linux

queue-admin provides a shell script for managing the mail queue of the qmail MTA.

queue-admin is a bash2 shell script for managing the mail queue of the qmail MTA.

It can provide a summarized list of the messages in the queue, optionally filtered by number or by whether a message is local or remote.

The messages themselves can be listed, viewed, or deleted by the same criteria.

It can also search for expressions within the messages, and can return the entire email or only the line where the expression was found.

The output is colorized.

pfqueue is a console-based tool for handling MTA queues.

pfqueue is an effort to give postqueue/mailq/postsuper/exim4 a console (ncurses) interface: it wont add any particular functionality to those provided with MTAs themselves, but will hopefully make them easier to use.

Its a real-time queue scanner, that shows per-queue lists of existing messages; the messages can be shown, deleted, put on hold, released or requeued.

Just for example, it may be useful to inspect a traffic jam at a given time, to see what is falling into and unexpectedly crowding your deferred queue.

IPC::DirQueue is a disk-based many-to-many task queue.

SYNOPSIS

my $dq = IPC::DirQueue->new({ dir => "/path/to/queue" });
$dq->enqueue_file("filename");

my $dq = IPC::DirQueue->new({ dir => "/path/to/queue" });
my $job = $dq->pickup_queued_job();
if (!$job) { print "no jobs leftn"; exit; }
# ...do something interesting with $job->get_data_path() ...
$job->finish();

This module implements a FIFO queueing infrastructure, using a directory as the communications and storage media. No daemon process is required to manage the queue; all communication takes place via the filesystem.

A common UNIX system design pattern is to use a tool like lpr as a task queueing system; for example, http://patrick.wagstrom.net/old/weblog/archives/000128.html describes the use of lpr as an MP3 jukebox.

However, lpr isnt as efficient as it could be. When used in this way, you have to restart each task processor for every new task. If you have a lot of startup overhead, this can be very inefficient. With IPC::DirQueue, a processing server can run persistently and cache data needed across multiple tasks efficiently; it will not be restarted unless you restart it.

Multiple enqueueing and dequeueing processes on multiple hosts (NFS-safe locking is used) can run simultaneously, and safely, on the same queue.

Since multiple dequeuers can run simultaneously, this provides a good way to process a variable level of incoming tasks using a pre-defined number of worker processes.

If you need more CPU power working on a queue, you can simply start another dequeuer to help out. If you need less, kill off a few dequeuers.

If you need to take down the server to perform some maintainance or upgrades, just kill the dequeuer processes, perform the work, and start up new ones. Since theres no socket or similar point of failure aside from the directory itself, the queue will just quietly fill with waiting jobs until the new dequeuer is ready.

Arbitrary name = value string-pair metadata can be transferred alongside data files. In fact, in some cases, you may find it easier to send unused and empty data files, and just use the metadata fields to transfer the details of what will be worked on.

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).

POE::XS::Queue::Array is an XS implementation of POE::Queue::Array.

This class is an implementation of the abstract POE::Queue interface. It implements a priority queue using C, with an XS interface supplied.

The current implementation could use some optimization, especially for large queues.

Please see the POE::Queue documentation, which explains this ones functions, features, and behavior.

The following extra methods are added beyond POE::Queue::Array:

dump

Dumps the internal structure of the queue to stderr.

verify

Does limited verification of the structure of the queue. If the verification fails then a message is sent to stderr and the queue is dumped as with the dump() method, and your program will exit.

qSheff is a a email filter and a wrapper for the qmail queue that scans email for viruses and spam. Infected messages are rejected before they reach the queue, so the server doesnt perform any job for them. After checking the message, it will wake the qmail queue.
Main features:
- Simple, optimized, extandable fast code (C code)
- Interoperability with various Antivirus.
- Could logs all incoming/outgoing mails
- Subject/body filter.
- Attachment blocking by name and extension.
- White/black lists.
- Easy installation and administration (qsheff/qsheff.* files)
- Easy debugging.
- Quarantine for service providers.
- Dropping mails with malformed headers
- MRTG reporting
Enhancements:
- All menu keys have been redesigned.
- The code was tested for stability.

Sidebrain is a programmers memory aide.

It is a working memory tool for programmers: it maintains a stack of your current tasks, and a queue or pool of pending tasks, and a set of observations, to help to remind you what youre doing.

This is a fairly new project; for what I can tell so far, it helps me to keep focused on what Im doing.