File Coverage

blib/lib/Mail/Run/Crypt.pm

Criterion	Covered	Total	%
statement	39	61	63.9
branch	15	28	53.5
condition	0	3	0.0
subroutine	11	13	84.6
pod	3	3	100.0
total	68	108	62.9

package Mail::Run::Crypt;

# Force me to write this properly
use strict;
use warnings;
use utf8;

# Require this version of Perl
use 5.008_001;

# Import required modules
use Carp;
use English '-no_match_vars';
use IPC::Run3;
use Mail::GnuPG;
use MIME::Entity;

# Specify package verson
our $VERSION = '0.11';

# Default exit value
our $DEFAULT_EXIT = 127;    ## no critic (ProhibitMagicNumbers)

# Oldschool constructor
sub new {
    my ( $class, %opts ) = @_;

    # Blindly slurp in all the options given
    my $self = {%opts};

    # We must have a recipient
    defined $self->{mailto}
      or croak 'MAILTO required';

    # Default the instance name to the package name if it wasn't given;
    # runcrypt(1) will pass it in
    defined $self->{name} or $self->{name} = $class;

    # We default to encrypting but not signing
    defined $self->{encrypt} or $self->{encrypt} = 1;
    defined $self->{sign}    or $self->{sign}    = 0;

    # If signing, we need a key ID and a passphrase
    if ( $self->{sign} ) {
        defined $self->{keyid}
          or croak 'Key ID required for signing';
        defined $self->{passphrase}
          or croak 'Passphrase required for signing';
    }

    # Return objectified self
    return bless $self, $class;
}

# Run a given command
sub run {
    my ( $self, @command ) = @_;

    # Run the command and wait for it to finish; keep its exit value for later
    my ( @out, @err );
    eval { run3 \@command, undef, \@out, \@err }
      or warn "Command failed: $EVAL_ERROR\n";
    $self->{exit} = $CHILD_ERROR >> 8;

    # If there was output, mail it
    if (@out) {
        my $command = join q{ }, @command;
        my $subject = "$self->{name} output: $command";
        $self->_mail( $subject, \@out );
    }

    # If there were errors, mail them
    if (@err) {
        my $command = join q{ }, @command;
        my $subject = "$self->{name} errors: $command";
        $self->_mail( $subject, \@err );
    }

    # Return status reflecting the command exit value
    return $self->{exit} == 0;
}

# Return the value of the most recently run command, or 1 otherwise
sub bail {
    my $self = shift;
    my $exit =
      defined $self->{exit}
      ? $self->{exit}
      : $DEFAULT_EXIT;
    return $exit;
}

# Send the message to the address in $ENV{MAILTO}
sub _mail {
    my ( $self, $subject, $content ) = @_;

    # Build MIME object with plaintext message
    my $mime = MIME::Entity->build(
        To      => $self->{mailto},
        Subject => $subject,
        Data    => $content,
    );

    # Encrypt the MIME object
    my $mgpg = Mail::GnuPG->new(
        key        => $self->{keyid},
        passphrase => $self->{passphrase},
    );

    # Sign and/or encrypt as appropriate
    if ( $self->{sign} and $self->{encrypt} ) {
        $mgpg->mime_signencrypt( $mime, $self->{mailto} );
    }
    elsif ( $self->{sign} ) {
        $mgpg->mime_sign( $mime, $self->{mailto} );
    }
    elsif ( $self->{encrypt} ) {
        $mgpg->mime_encrypt( $mime, $self->{mailto} );
    }

    # Send it
    return $mime->send();
}

1;

__END__