NAME

       AnyEvent::Redis - Non-blocking Redis client

SYNOPSIS

         use AnyEvent::Redis;

         my $redis = AnyEvent::Redis->new(
             host => '127.0.0.1',
             port => 6379,
             encoding => 'utf8',
             on_error => sub { warn @_ },
             on_cleanup => sub { warn "Connection closed: @_" },
         );

         # callback based
         $redis->set( 'foo'=> 'bar', sub { warn "SET!" } );
         $redis->get( 'foo', sub { my $value = shift } );

         my ($key, $value) = ('list_key', 123);
         $redis->lpush( $key, $value );
         $redis->lpop( $key, sub { my $value = shift });

         # condvar based
         my $cv = $redis->lpop( $key );
         $cv->cb(sub { my $value = $_[0]->recv });

DESCRIPTION

       AnyEvent::Redis is a non-blocking (event-driven) Redis client.

       This module is an AnyEvent user; you must install and use a supported event loop.

ESTABLISHING A CONNECTION

       To create a new connection, use the new() method with the following attributes:

       host => <HOSTNAME>
           Required.  The hostname or literal address of the server.

       port => <PORT>
           Optional.  The server port.

       encoding => <ENCODING>
           Optional.   Encode  and decode data (when storing and retrieving, respectively) according to ENCODING
           ("utf8" is recommended or see Encode::Supported for details on possible ENCODING values).

           Omit if you intend to handle raw binary data with this connection.

       on_error => $cb->($errmsg)
           Optional.  Callback that will be fired if a connection or database-level  error  occurs.   The  error
           message will be passed to the callback as the sole argument.

       on_cleanup => $cb->($errmsg)
           Optional.   Callback  that  will  be  fired  if a connection error occurs.  The error message will be
           passed to the callback as the sole argument.  After this callback, errors will be  reported  for  all
           outstanding requests.

METHODS

       All methods supported by your version of Redis should be supported.

   Normal commands
       There are two alternative approaches for handling results from commands:

       •   AnyEvent::CondVar based:

             my $cv = $redis->command(
               # arguments to command
             );

             # Then...
             my $res;
             eval {
                 # Could die()
                 $res = $cv->recv;
             };
             warn $@ if $@;

             # or...
             $cv->cb(sub {
               my ($cv) = @_;
               my ($result, $err) = $cv->recv
             });

       •   Callback:

             $redis->command(
               # arguments,
               sub {
                 my ($result, $err) = @_;
               });

           (Callback is a wrapper around the $cv approach.)

   Transactions (MULTI/EXEC)
       Redis  transactions begin with a "multi" command and end with an "exec" command.  Commands in between are
       not executed immediately when they're sent.  On receipt of the "exec", the server executes all the  saved
       commands atomically, and returns all their results as one bulk reply.

       After  a  transaction  is  finished,  results  for each individual command are reported in the usual way.
       Thus, by the time any of these callbacks is called, the entire transaction  is  finished  for  better  or
       worse.

       Results  of  the  "exec"  (containing  all  the  other  results)  will  be returned as an array reference
       containing all of the individual results.  This may in  some  cases  make  callbacks  on  the  individual
       commands unnecessary, or vice versa.  In this bulk reply, errors reported for each individual command are
       represented by objects of class "AnyEvent::Redis::Error", which will respond to a "->message" method call
       with that error message.

       It is not permitted to nest transactions.  This module does not permit subscription-related commands in a
       transaction.

   Subscriptions
       The subscription methods ("subscribe" and "psubscribe") must be used with a callback:

         my $cv = $redis->subscribe("test", sub {
           my ($message, $channel[, $actual_channel]) = @_;
           # ($actual_channel is provided for pattern subscriptions.)
         });

       The $cv condition will be met on unsubscribing from the channel.

       Due  to  limitations  of  the  Redis  protocol  the  only  valid  commands on a connection with an active
       subscription are subscribe and unsubscribe commands.

   Common methods
       •   get

       •   set

       •   hset

       •   hget

       •   lpush

       •   lpop

       The Redis command reference (<http://redis.io/commands>) lists all commands Redis supports.

REQUIREMENTS

       This requires Redis >= 1.2.

COPYRIGHT

       Tatsuhiko Miyagawa <miyagawa@bulknews.net> 2009-

LICENSE

       This library is free software; you can redistribute it and/or modify it under  the  same  terms  as  Perl
       itself.

AUTHORS

       Tatsuhiko Miyagawa

       David Leadbeater

       Chia-liang Kao

       franck cuny

       Lee Aylward

       Joshua Barratt

       Jeremy Zawodny

       Leon Brocard

       Michael S. Fischer

       Chip Salzenberg

SEE ALSO

       Redis, AnyEvent

perl v5.38.2                                       2024-03-04                               AnyEvent::Redis(3pm)