File Coverage

blib/lib/Starch/Store/CHI.pm

Criterion	Covered	Total	%
statement	32	32	100.0
branch	1	2	50.0
condition			n/a
subroutine	10	10	100.0
pod	2	2	100.0
total	45	46	97.8

package Starch::Store::CHI;

$Starch::Store::CHI::VERSION = '0.04';

=head1 NAME

Starch::Store::CHI - Starch storage backend using CHI.

=head1 SYNOPSIS

    my $starch = Starch->new(
        store => {
            class => '::CHI',
            chi => {
                driver => 'File',
                root_dir => '/path/to/root',
            },
        },
        ...,
    );

=head1 DESCRIPTION

This L store uses L to set and get state data.

=head1 EXCEPTIONS

By default L will catch errors and log them using L
and keep on going as if nothing went wrong.  In Starch, stores are
expected to loudly throw exceptions, so it is suggested that you
specify these arguments to your CHI driver:

    on_get_error => 'die',
    on_set_error => 'die',

And then, if you still want the errors logged, you can use
L.  This is especially
important if you are using the L
plugin which will throw an exception when the timeout is exceeded
which then CHI will catch and log by default, which is not what
you want.

=head1 PERFORMANCE

When using CHI there are various choices you need to make:

=over

=item *

Which backend to use?  If data persistence is not an issue, or
you're using CHI as your outer store in L
then Memcached or Redis are common solutions which have high
performance.

=item *

Which serializer to use?  Nowadays L is the serialization
performance heavyweight, with L coming up a close second.

=item *

Which driver to use?  Some backends have more than one driver, and
some drivers perform better than others.  The most common example of
this is Memcached which has three drivers which can be used with
CHI.

=back

Make sure you ask these questions when you implement CHI for
Starch, and take the time to answer them well.  It can make a big
difference.

=cut

use CHI;
use Types::Standard -types;
use Types::Common::String -types;
use Scalar::Util qw( blessed );

use Moo;
use strictures 2;
use namespace::clean;

with qw(
    Starch::Store
);

after BUILD => sub{
  my ($self) = @_;

  # Get this loaded as early as possible.
  $self->chi();

  return;
};

=head1 REQUIRED ARGUMENTS

=head2 chi

This must be set to either hash ref arguments for L or a
pre-built CHI object (often retrieved using a method proxy).

When configuring Starch from static configuration files using a
L
is a good way to link your existing L object constructor
in with Starch so that starch doesn't build its own.

=cut

has _chi_arg => (
    is       => 'ro',
    isa      => (InstanceOf[ 'CHI::Driver' ]) | HashRef,
    init_arg => 'chi',
    required => 1,
);

has chi => (
    is       => 'lazy',
    isa      => InstanceOf[ 'CHI::Driver' ],
    init_arg => undef,
);
sub _build_chi {
    my ($self) = @_;

    my $chi = $self->_chi_arg();
    return $chi if blessed $chi;

    return CHI->new( %$chi );
}

=head1 METHODS

=head2 set

Set L.

=head2 get

Set L.

=head2 remove

Set L.

=cut

sub set {
    my ($self, $id, $namespace, $data, $expires) = @_;

    local $Carp::Interal{ (__PACKAGE__) } = 1;

    $self->chi->set(
        $self->stringify_key( $id, $namespace ),
        $data,
        $expires ? ($expires) : (),
    );

    return;
}

sub get {
    my ($self, $id, $namespace) = @_;

    local $Carp::Interal{ (__PACKAGE__) } = 1;

    return $self->chi->get(
        $self->stringify_key( $id, $namespace ),
    );
}

sub remove {
    my ($self, $id, $namespace) = @_;

    local $Carp::Interal{ (__PACKAGE__) } = 1;

    $self->chi->remove(
        $self->stringify_key( $id, $namespace ),
    );

    return;
}

1;
__END__