view release on metacpan or  search on metacpan

README  view on Meta::CPAN

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.