NAME

SYNOPSIS

  #!/usr/bin/perl -w
  package MyPackage;

  use Mail::Spool;
  @ISA = qw(Mail::Spool);

  my $spool = Mail::Spool->new();

  $spool->dequeue_dir = '/var/spool/mail';

  $spool->daemon;
  exit;

  # OR

  use Mail::Spool qw(send_mail);
  my $args = {to   => 'anybody@in.the.world',
              from => 'me@right.here.local',
              delivery => 'Interactive', # or Deferred
              timeout  => 2 * 60, # two minutes
              filename =>
              #or# message  => $scalar,
              #or# message  => \$scalar,
              #or# message  => $a_mail_internet_object,
              #or# filehandle => $open_io_handle,
              };
  my $spool = Mail::Spool->new();
  eval{ $spool->send_mail($args) };

  # OR

  eval{ send_mail($args) };
  if( $@ ){
    die "Something went wrong [$@]";
  }

OBTAINING

DESCRIPTION

It is also intended to be used as a quick spooling mechanism for perl scripts. As it can write straight to the queue without opening another process.

The send_mail method allows for either Deferred or Interactive sending of mail.

As of this writing, a version Mail::Spool has been in use in production for three months spooling and sending about 200MB a day in several thousand messages.

The default setup allows for setup on multiple servers, all sharing a common spool directory. NFS capable locking will take place in necessary areas.

PROPERTIES

  my $dequeue_dir = $self->dequeue_dir;
  $self->dequeue_dir($new_dequeue_dir);

The following properties are available:

dequeue_dir

Base location for the mail spool. Defaults to $Mail::Spool::DEQUEUE_DIR which at load time contains "/var/spool/mail".

dequeue_periods

An array ref containing the amount of time a message must wait in the spool and fallback spools. Defaults to $Mail::Spool::DEQUEUE_PERIODS which at load time contains an array ref with 0, .5*3600, 4*3600, 8*3600, 16*3600, 24*3600, and 48*3600 as its values. A directory for each of these times will be created (0 will be in dequeue_dir/0, .5*3600 will be dequeue_dir/1, etc). For a further discussion of dequeue times and methods, please read the extended comment in the source code under the subroutine list_spool_handles.

dequeue_priority

An array ref containing an equal number of elements as dequeue_periods. Elements should be integers. Defaults to $Mail::Spool::DEQUEUE_PRIORITY which at load time contains an array ref with 1, 3, 9, 25, 50, 100, and 200 as its values. A lower number means higher priority. With a 20 second dequeue_timeout, a priority of 1 checks the queue every 20 seconds, 3 checks every 60 seconds, and 200 checks every 66 minutes. For a further discussion of dequeue times and methods, please read the extended comment in the source code under the subroutine list_spool_handles.

dequeue_timeout

Seconds to wait before before looking through the queues. Defaults to $Mail::Spool::DEQUEUE_TIMEOUT which at load time is 20 (seconds).

max_dequeue_processes

Maximum number of dequeue processes to start under a daemon. Defaults to $Mail::Spool::MAX_DEQUEUE_PROCESSES which at load time is 20.

max_connection_time

Maximum amount of time to stay connected to a remote host. Defaults to $Mail::Spool::MAX_CONNECTION_TIME which at load time is 6*60*60 (6 hours). Messages not delivered under this time period are queued for later delivery.

usage_log

Location to store raw spool usage information. Defaults to $Mail::Spool::USAGE_LOG which at load time is "$Mail::Spool::DEQUEUE_DIR/usage".

METHODS

new

Returns an object blessed into the passed class. A hash, or hashref passed to the the method will be set as hash keys of the object.

daemon

Starts a mail spool daemon using Net::Server::Fork as the back end. Will run continuously until the main process is killed. Log information defaults to 'Sys::Syslog'.

create_dequeue_dirs

May be called as a method or function. Hook to create the necessary directories used by the spool daemon.

list_spool_handles

Returns a list of objects blessed into the Mail::Spool::Handle class (by default). These handle objects represent the queue (spools) that need to be processed at the moment. For an important discussion of architecture and waiting times, please read the comments in the source code located within this subroutine.

mail_spool_handle

Returns an object blessed into the Mail::Spool::Handle class. See Mail::Spool::Handle.

mail_spool_node

Returns an object blessed into the Mail::Spool::Node class. See Mail::Spool::Node.

dequeue

May be called as a method or function. Run through a dequeue process. This consists of listing spool handles, opening the spools, reading nodes from the spools, and having the nodes fallback upon failed delivery. Dequeue is called periodically based upon dequeue_timeout one the daemon process has been started.

parse_for_address

Short wrapper around Mail::Address->parse. Should take an email address line and return a list of objects that can support ->address, ->domain, and ->format methods. See Mail::Address.

new_message_id

During the send_mail process if a message is deferred, the spooler will attempt to parse a message id from the email. If none can be found, this method is called to generate a new id which will be used in the spooling process.

send_mail

May be called as a method or function. Send mail takes a message and either sends it off or places it in the queue. Arguments are a hash or a hashref. The possible arguments to send_mail are as follows:

parse_message

Based upon the arguments given, returns an object that possesses the correct methods for use in the send_mail routine. Arguments may be given either as a hash or a hashref. The main arguments are "message," "filehandle," or "filename.". Message may be either a scalar or scalar ref containing the message, an array ref containing the lines of the message, or an object which supports head, body, and print methods (such as Mail::Internet, or MIME::Entity) (actually the object needs to support head, print, body, header, head->get, head->add, and head->delete). If there is no message argument, and there is a "filehandle" argument, parse_message will create an object from the filehandle (the filehandle should be an IO::Handle style object). If no filehandle is given, parse_message will look for a "filename" argument. This should be a readable filename accessible by the spooler. In all cases, the passed message should contain the email headers necessary. If it does not, the headers will be added as necessary. This method returns a Mail::Internet compatible object.

_send_mail_deferred

Called by send_mail. Arguments should a hash or hash ref. Places the message contained in the "message" argument into the mail spool and returns immediately. Required arguments are "message," "to," "from," "id," and "msh" (a Mail::Spool::Handle object).

_send_mail_now

Called by send_mail. Arguments shoud be a hash or hash ref. Required arguments are "message," "to," "from," "id," "timeout," and "delivery." Looks up the mx records of the domain found in "to" using the lookup_mx method, and iterates through each of these records and tries to open a connection using open_smtp_connection (times out after "timeout" seconds). Once a connection has been established, sends the message, testing responses using check_sock_status. If delivery is "Background," and a connection could not be established, the message will be queued for later delivery. Any errors die.

check_sock_status

Checks the status of the last smtp command. Arguments are the open socket, the mx host, the to address, and the from address. Any errors die.

lookup_mx

Takes a hostname as an argument. Should return a list of the mx records for that hostname, ordered by their priorities. This method could also be sub classed to allow for caching of the response.

lookup_host

Takes a hostname as an argument. Should return a hostname or an ip address. Intended as a means of caching records. Default is to simply return the passed host.

open_smtp_connection

Takes a hostname as an argument. Returns a IO::Socket style object containing an open connection to that host (or undef on failure). This could be overridden to allow for holding the connection open across several emails to the same domain.

log_usage

Takes a number and word as arguments. Writes this information out to a very simple log. Intended for gathering basic spool information, such as total bytes spooled and total bytes sent, as well as total messages spooled and sent.

AUTOLOAD

Used to dynamically some of the property methods.

TO DO

Use It

The best way to further the status of this project is to use it. A less extensible version of this module has been in use for around three months as of this writing.

Extensions

Explore other extenstions such as optimized read of spool directories to order by domain. Possibly add interface to allow placing mail in postfix and sendmail compatible queues.

DNS

Add modules to handle DNS caching.

Interfaces

Add modules containing interfaces to databases, or other "file systems".

BUGS

SEE ALSO

COPYRIGHT

  Copyright (C) 2001, Paul T Seamons
                      paul@seamons.com
                      http://seamons.com/

  This package may be distributed under the terms of either the
  GNU General Public License
    or the
  Perl Artistic License

  All rights reserved.