File Coverage

blib/lib/XAS/Lib/Modules/Spool.pm

Criterion	Covered	Total	%
statement	12	116	10.3
branch	0	18	0.0
condition			n/a
subroutine	4	21	19.0
pod	7	7	100.0
total	23	162	14.2

package XAS::Lib::Modules::Spool;

our $VERSION = '0.03';

use Try::Tiny;
use XAS::Factory;
use XAS::Constants 'LOCK_DRIVERS';

use XAS::Class
  debug      => 0,
  version    => $VERSION,
  base       => 'XAS::Base',
  mixin      => 'XAS::Lib::Mixins::Handlers',
  utils      => ':validation dotid',
  filesystem => 'Dir File',
  accessors  => 'lockmgr',
  vars => {
    PARAMS => {
      -directory => { isa => 'Badger::Filesystem::Directory' },
      -mask      => { optional => 1, default => 0664 },
      -lock      => { optional => 1, default => undef },
      -extension => { optional => 1, default => '.pkt' },
      -seqfile   => { optional => 1, default => '.SEQ' },
      -driver    => { optional => 1, default => 'Filesystem', regex => LOCK_DRIVERS },
    }
  }
;

#use Data::Dumper;

# ------------------------------------------------------------------------
# Public Methods
# ------------------------------------------------------------------------

sub read {
    my $self = shift;
    my ($filename) = validate_params(\@_, [
        { isa => 'Badger::Filesystem::File' },
    ]);

    my $packet;

    if ($self->lockmgr->lock($self->lock)) {

        $packet = $self->_read_packet($filename);
        $self->lockmgr->unlock($self->lock);

    } else {

        $self->throw_msg(
            dotid($self->class) . '.read.lock_error',
            'lock_dir_error',
            $self->directory->path
        );

    }

    return $packet;

}

sub write {
    my $self = shift;
    my ($packet) = validate_params(\@_, [ 1 ]);

    my $seqnum;

    if ($self->lockmgr->lock($self->lock)) {

        $seqnum = $self->_sequence();

        $self->_write_packet($packet, $seqnum);
        $self->lockmgr->unlock($self->lock);

    } else {

        $self->throw_msg(
            dotid($self->class) . '.write.lock_error',
            'lock_dir_error',
            $self->directory->path
        );

    }

    return 1;

}

sub scan {
    my $self = shift;

    my @files;
    my $regex = $self->extension;
    my $pattern = qr/$regex/i;

    if ($self->lockmgr->lock($self->lock)) {

        @files = sort(grep( $_->path =~ $pattern, $self->directory->files() ));
        $self->lockmgr->unlock($self->lock);

    } else {

        $self->throw_msg(
            dotid($self->class) . '.scan.lock_error',
            'lock_dir_error',
            $self->directory->path
        );

    }

    return @files;

}

sub delete {
    my $self = shift;
    my ($file) = validate_params(\@_, [
        { isa => 'Badger::Filesystem::File' },
    ]);

    if ($self->lockmgr->lock($self->lock)) {

        $file->delete;
        $self->lockmgr->unlock($self->lock);

    } else {

        $self->throw_msg(
            dotid($self->class) . '.delete.lock_error',
            'lock_dir_error',
            $self->directory->path
        );

    }

}

sub count {
    my $self = shift;

    my @files;
    my $count;
    my $regex = $self->extension;
    my $pattern = qr/$regex/i;

    if ($self->lockmgr->lock($self->lock)) {

        @files = grep( $_->path =~ $pattern, $self->directory->files() );
        $count = scalar(@files);

        $self->lockmgr->unlock($self->lock);

    } else {

        $self->throw_msg(
            dotid($self->class) . '.count.lock_error',
            'lock_dir_error',
            $self->directory->path
        );

    }

    return $count;

}

sub get {
    my $self = shift;

    my @files;
    my $filename;
    my $pattern = qr/$self->extension/i;

    if ($self->lockmgr->lock($self->lock)) {

        @files = sort(grep( $_->path =~ /$pattern/, $self->directory->files() ));
        $filename = $files[0];

        $self->lockmgr->unlock($self->lock);

    } else {

        $self->throw_msg(
            dotid($self->class) . '.get.lock_error',
            'lock_dir_error',
            $self->directory->path
        );

    }

    return $filename;

}

# ------------------------------------------------------------------------
# Private Methods
# ------------------------------------------------------------------------

sub init {
    my $class = shift;

    my $self = $class->SUPER::init(@_);

    unless (defined($self->{'lock'})) {

        $self->{'lock'} = Dir($self->env->locks, 'spool')->path;

    }

    $self->{'lockmgr'} = XAS::Factory->module('lockmgr');

    $self->lockmgr->add(
        -key    => $self->lock,
        -driver => $self->driver,
    );

    return $self;

}

sub _chmod {
    my $self = shift;
    my $file = shift;

    my $mask = $self->mask + 0;
    my $cnt = chmod($mask, $file);

    if ($cnt < 1) {

        $self->throw_msg(
            dotid($self->class) . '.chmod.invperms',
            'invperms',
            $file
        );

    }

}

sub _sequence {
    my $self = shift;

    my $fh;
    my $seqnum;
    my $file = File($self->directory, $self->seqfile);

    try {

        if ($file->exists) {

            $fh = $file->open("r+");
            $seqnum = $fh->getline;
            $seqnum++;
            $fh->seek(0, 0);
            $fh->print($seqnum);
            $fh->close;

        } else {

            $fh = $file->open("w");
            $fh->print("1");
            $fh->close;

            $self->_chmod($file);

            $seqnum = 1;

        }

    } catch {

        my $ex = $_;

        $self->throw_msg(
            dotid($self->class) . '.sequence',
            'spooler_sequence',
            $file
        );

    };

    return $seqnum;

}

sub _write_packet {
    my $self = shift;
    my ($packet, $seqnum) = validate_params(\@_, [1,1]);

    my $fh;
    my $file = File($self->directory, $seqnum . $self->extension);

    try {

        $fh = $file->open("w");
        $fh->print($packet);
        $fh->close;

        $self->_chmod($file->path);

    } catch {

        my $ex = $_;

        $self->throw_msg(
            dotid($self->class) . '.write_packet',
            'spooler_write_packet',
            $file->path
        );

    };

}

sub _read_packet {
    my $self = shift;
    my ($file) = validate_params(\@_, [
        { isa => 'Badger::Filesystem::File' }
    ]);

    my $fh;
    my $packet;

    try {

        $fh = $file->open("r");
        $packet = $fh->getline;
        $fh->close;

    } catch {

        my $ex = $_;

        $self->throw_msg(
            dotid($self->class) . '.read_packet',
            'spooler_read_packet',
            $file->path
        );

    };

    return $packet;

}

1;

__END__