AnyEvent-RipeRedis

 view release on metacpan or  search on metacpan

examples/subs.pl  view on Meta::CPAN

        warn $err->message . "\n";
        return;
      };

      print 'Unsubscribed from: ' . join( ', ', @patterns ). "\n";

      $cv->send;
    }
  );

  my $timer;
  $timer = AE::timer( 5, 0,
    sub {
      undef( $timer );
      exit 0; # Emergency exit
    },
  );
};

my $int_w  = AE::signal( INT  => $on_signal );
my $term_w = AE::signal( TERM => $on_signal );

$cv->recv;

examples/unix_socket.pl  view on Meta::CPAN

  on_connect => sub {
    print "Connected to Redis server\n";
  },

  on_disconnect => sub {
    print "Disconnected from Redis server\n";
  },
);

my $timer;
$timer = AE::timer( 0, 1,
  sub {
    $redis->incr( 'foo',
      sub {
        my $reply = shift;
        my $err   = shift;

        if ( defined $err ) {
          warn $err->message . "\n";
          return;
        }

lib/AnyEvent/RipeRedis.pm  view on Meta::CPAN

      }
    }
    elsif ( $self->{lazy} ) {
      undef $self->{lazy};
      $self->_connect;
    }
    elsif ( $self->{reconnect} ) {
      if ( defined $self->{reconnect_interval}
        && $self->{reconnect_interval} > 0 )
      {
        unless ( defined $self->{_reconnect_timer} ) {
          weaken($self);

          $self->{_reconnect_timer} = AE::timer(
            $self->{reconnect_interval}, 0,
            sub {
              undef $self->{_reconnect_timer};
              $self->_connect;
            }
          );
        }
      }
      else {
        $self->_connect;
      }
    }
    else {

lib/AnyEvent/RipeRedis.pm  view on Meta::CPAN

sub _reset_internals {
  my $self = shift;

  $self->{_handle}             = undef;
  $self->{_connected}          = 0;
  $self->{_auth_state}         = S_NEED_DO;
  $self->{_db_selection_state} = S_NEED_DO;
  $self->{_ready}              = 0;
  $self->{_multi_mode}         = 0;
  $self->{_reconnect_timer}    = undef;

  return;
}

sub _abort {
  my $self = shift;
  my $err  = shift;

  my @queued_commands = $self->_queued_commands;
  my %channels        = %{ $self->{_channels} };

t/07-lazy-conn.t  view on Meta::CPAN

      host       => $SERVER_INFO->{host},
      port       => $SERVER_INFO->{port},
      lazy       => 1,
      reconnect  => 0,

      on_connect => sub {
        $T_CONNECTED = 1;
      },
    );

    my $timer;
    $timer = AnyEvent->timer(
      after => 3,
      cb    => sub {
        undef $timer;

        ok( !$T_CONNECTED, 'lazy connection (no connected yet)' );

        $redis->ping(
          sub {
            my $reply = shift;
            my $err   = shift;

            if ( defined $err ) {
              diag( $err->message );

t/09-conn-errors.t  view on Meta::CPAN

            my $reply = shift;
            my $err   = shift;

            if ( defined $err ) {
              diag( $err->message );
              $cv->send;

              return;
            }

            my $timer;
            $timer = AE::postpone(
              sub {
                undef $timer;
                $server_info->{server}->stop;
              }
            );
          }
        );
      }
    );

    $server_info = run_redis_instance(
      port => $port,

t/test_helper.pl  view on Meta::CPAN

  };
}

sub ev_loop {
  my $sub = shift;

  my $cv = AE::cv;

  $sub->($cv);

  my $timer = AE::timer( 15, 0,
    sub {
      diag( 'Emergency exit from event loop.' );
      $cv->send;
    }
  );

  $cv->recv;

  return;
}