The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
 / 
Cache-Memcached-Queue-0.1.4
River stage zero No dependents
++
/ Cache::Memcached::Queue

NAME

Cache::Memcached::Queue - Create queues and save them on memcached!

VERSION

Version 0.1.4

beta version

DESCRIPTION

This works by taking advantage of Memcached infrastructure. In other words, the 'keys' will be strings that are names of indexes for some basic values that are sufficient to represent a queue structure. This basic values are: first, last, size and max_enq.

In order to have multiples queues in the same Memcached server, a prefix are added to every index on keys of Memcached. So, every key in memcached have the following struct on his name: <PREFIX>_<ID>_<INDEX_NUMBER OR NAME>

PREFIX - This is defined by the 'id_prefix' attribute. The default value is 'CMQID_'
ID - This is defined by the 'id' attribute.
INDEX_NUMBER OR NAME - If some data is a item in the queue, so this must be a sequential number, for example: 'CMQID_1_1' This can be the first element from queue with id 1. If some data in the queue is a pointer, this pointer must be named, for example: 'CMQID_1_first' This is the pointer to the first element in queue.

SYNOPSIS

This module implements a simple scheme of a Queue.

    use Cache::Memcached::Queue;

    my $q = Cache::Memcached::Queue->new( name => 'foo', #this is mandatory
                                                max_enq => 10,
                                                config_file => 'path_to_config/configfile.cfg',
                                                id => 1,
                                                serialize => 1, #if true, every value on enq will be serialized
                                                serializer => sub { return Data::Serializer->new( serializer => 'Storable',
                                                                                                                         compress => 1,
                                                                                                                )
                                                                                ); }, #RTFM Data::Serializer for more options...

        'init' method is DEPRECATED!
    
        #loading queue                  
    $q->load();#load data from Memcached

        #common operations...
    $q->enq('duke'); #enqueue 'duke'. 

    $q->enq('nuken'); #enqueue 'nuke' and this never expires on memcached 

    $q->show; #show all items from queue. In this case: 'duke'(first element) and 'nuken'(last element).

    $q->deq; #deqeue 'duke'. 

    $q->show; #show all items from queue. In this case: 'nuke'(first and last element from queue).

#alternative enq

        $q->enq({ value => 'duke' });
        
        #serialize just one value(serialize attribute must be false)
        $q->enq({ value => 'nuken' , serialize => 1});

init()

Initialize object attributes and check attributes problems. If all is ok, returns the reference to object. Otherwise returns undef and trows an exception

load()

Try to load the queue pointers from Memcached. If works, will return true. Otherwise will return false.

enq( HashRef $parameters or SCALAR $value )

Try to make a 'enqueue' operation. That means tha 'last' index pointer will be readjusted to the next index. So the value can be recorded on Memcached.

The parameters are validated, and the valid parameters are:

value - A value that presupposes that you want to save
serialize - If you need the value to be serialized, you must set serialized to true(1).

Example: $enq({value => 'some_value'});

Example2: $enq({value => $some_object_or_structure, serialize => 1, });

 If this work, the method will return true. Otherwise, will return false.

 You can change serialize parameters setting 'serializer' method.

deq()

Try to make a 'dequeue' operation on Queue. That means the first value of queue will be removed from queue, and the first index pointer from queue will be moved to the next index. If works, returns the 'dequeued' value, otherwise returns undef.

show()

Try to show the content of queue(the data). This is made finding the 'first' and 'last' pointers, extracting the sequential index, and interate the queue with this indexes, making a 'get' operation from Memcached. If the value exists, it will be showed. If not, a exception will be thrown .

cleanup()

Dequeue everything! No parameters! Returns true, if it's all right! Otherwise, returns false/throws an exception

save( ArrayRef $parameters )

Try to save queue pointers on Memcached. The parameters came on arrayref, when each position of arrayref is a name of attribute that must be saved. This parameters are validated and then saved on memcached.

That makes the enqueuing process faster than save all parameters everytime, because the input operations on Memcached are reduced.

Ex: $q->save(['name','first']);

The valid parameters are:

name - Is the name of Queue;
first - Is the first index of the key. Not the value, but the name of index;
last - As the same way, this is the last index of the queue.

If everything work well the method returns true. Otherwise returns false.

iterate(CODE $action, ArrayRef $action_params)

 That method is a 'handler'. You can treat all values in another subroutine/static method, passing
two parameters:

  • action: this parameter MUST be a CODE reference. Example:

                                                                                    #EX1: $q->iterate( 
                                                                                        sub {   
                                                                                                        my ($index,$value,$params) = @_;
                                                                                                        #do something with this!!!
                                                                                        }

                                                                                #EX2: $q->iterate( \&somesubroutine,$myparams) ;
                                                                                        sub somesubroutine {
                                                                                                my ($index,$value,$params) = @_;
                                                                                                #do something cool!
                                                                                        }

  • action_params: This can be a custom parameters. All yours! You need pass this as a ArrayRef!

 So, by default, every index and values that are in your queue are passed together with your customized parameters.

 If you pass everything right, your 'action' will be performed! Otherwise, an exception will be throwed.

AUTHOR

Andre Garcia Carneiro, <bang at cpan.org>

BUGS

Please report any bugs or feature requests to bug-cache-memcached-queue at rt.cpan.org, or through the web interface at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Cache-memcached-Queue. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.

NOTES FOR THIS VERSION

Serialization support is implemented
If you pass 'complex' data structure(hashes, arrays, objects etc), the value will be serialized even serialize attribute is false;
The new method 'iterator' allows delegate to other subroutine/static method queue data.

SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Cache::Memcached::Queue

You can also look for information at:

LICENSE AND COPYRIGHT

Copyright 2013 Andre Garcia Carneiro.

This program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as published by the Free Software Foundation; or the Artistic License.

See http://dev.perl.org/licenses/ for more information.