view release on metacpan or search on metacpan
lib/AnyEvent/MPRPC/Client.pm view on Meta::CPAN
use strict;
use warnings;
use Any::Moose;
use Carp;
use Scalar::Util 'weaken';
use AnyEvent;
use AnyEvent::Socket;
use AnyEvent::Handle;
use AnyEvent::MessagePack;
lib/AnyEvent/MPRPC/Client.pm view on Meta::CPAN
$self->connect_timeout
and $connect_timeout = $self->connect_timeout;
return $connect_timeout;
};
weaken $self;
$self->_connection_guard($guard);
}
sub call {
lib/AnyEvent/MPRPC/Client.pm view on Meta::CPAN
}
sub _handle_response_cb {
my $self = shift;
weaken $self;
return sub {
$self || return;
my ($handle, $res) = @_;
view release on metacpan or search on metacpan
$trace = sub { warn "$_[0] $_[1]\n" } if $trace && !ref $trace;
my $buf;
Scalar::Util::weaken $self;
$self->{rw} = AE::io $fh, 0, sub {
if (sysread $fh, $buf, 8192, length $buf) {
while ($buf =~ s/^([^\n]+)\n//) {
$trace->("mpv>" => "$1");
$self->cmd ($type => $obsid+0, $property);
$self->{obscb}{$obsid} = $cb;
defined wantarray and do {
my $unobserve = bless [$self, $self->{obscb}, $obsid], AnyEvent::MPV::Unobserve::;
Scalar::Util::weaken $unobserve->[0];
$unobserve
}
}
sub observe_property {
we can queue a dummy command, whose only purpose is to tell us when all
previous commands are done. We use C<get_version> for this.
The simplified code looks like this:
Scalar::Util::weaken $self;
$mpv->cmd ("get_version")->cb (sub {
$guards->{file_loaded} = $mpv->register_event (file_loaded => sub {
delete $guards->{file_loaded};
view release on metacpan or search on metacpan
lib/AnyEvent/MQTT.pm view on Meta::CPAN
use Net::MQTT::Constants;
use Net::MQTT::Message;
use Net::MQTT::TopicStore;
use Carp qw/croak carp/;
use Sub::Name;
use Scalar::Util qw/weaken/;
sub new {
my ($pkg, %p) = @_;
my $self =
lib/AnyEvent/MQTT.pm view on Meta::CPAN
my $self = shift;
print STDERR "cleanup\n" if DEBUG;
if ($self->{handle}) {
my $cv = AnyEvent->condvar;
my $handle = $self->{handle};
weaken $handle;
$cv->cb(sub { $handle->destroy });
$self->_send(message_type => MQTT_DISCONNECT, cv => $cv);
}
delete $self->{handle};
delete $self->{connected};
lib/AnyEvent/MQTT.pm view on Meta::CPAN
$hdl->destroy;
undef $hdl;
$cv->send(1);
});
my $weak_self = $self;
weaken $weak_self;
my @push_read_args = @{$p{push_read_args}||['line']};
my $sub; $sub = subname 'push_read_cb_for_'.$topic => sub {
my ($hdl, $chunk, @args) = @_;
print STDERR "publish: $chunk => $topic\n" if DEBUG;
my $send_cv = AnyEvent->condvar;
lib/AnyEvent/MQTT.pm view on Meta::CPAN
my ($self, $wait) = @_;
undef $self->{_keep_alive_handle};
my $method = $wait ? '_keep_alive_timeout' : '_send_keep_alive';
$self->{_keep_alive_waiting} = $wait;
my $weak_self = $self;
weaken $weak_self;
$self->{_keep_alive_handle} =
AnyEvent->timer(after => $self->{keep_alive_timer},
cb => subname((substr $method, 1).'_cb' =>
sub { $weak_self->$method(@_) }));
}
lib/AnyEvent/MQTT.pm view on Meta::CPAN
$cv = $self->{connect_cv};
}
return $cv if ($self->{handle});
my $weak_self = $self;
weaken $weak_self;
my $hd;
$hd = $self->{handle} =
AnyEvent::Handle->new(connect => [$self->{host}, $self->{port}],
($self->{tls} ? (tls => "connect") : ()),
lib/AnyEvent/MQTT.pm view on Meta::CPAN
$self->{connected} = 1;
$self->{connect_cv}->send(1) if ($self->{connect_cv});
delete $self->{connect_cv};
my $weak_self = $self;
weaken $weak_self;
$handle->on_drain(subname 'on_drain_cb' => sub {
print STDERR "drained\n" if DEBUG;
my $w = $weak_self->{_waiting};
$w->[1]->send(1) if (ref $w && defined $w->[1]);
lib/AnyEvent/MQTT.pm view on Meta::CPAN
sub anyevent_read_type {
my ($handle, $cb) = @_;
subname 'anyevent_read_type_reader' => sub {
my ($handle) = @_;
my $rbuf = \$handle->{rbuf};
weaken $rbuf;
return unless (defined $$rbuf);
while (1) {
my $msg = Net::MQTT::Message->new_from_bytes($$rbuf, 1);
last unless ($msg);
$cb->($handle, $msg);
view release on metacpan or search on metacpan
lib/AnyEvent/Memcached/Peer.pm view on Meta::CPAN
use warnings;
}x;
use base 'AnyEvent::Connection';
use Carp;
use AnyEvent::Connection::Util;
use Scalar::Util qw(weaken);
#use Devel::Leak::Cb;
sub DEBUG () { 0 }
use AnyEvent::Memcached::Conn;
lib/AnyEvent/Memcached/Peer.pm view on Meta::CPAN
}
elsif (!$self->{connected}) {
my @args = @$args; # copy to avoid rewriting
warn time()." Not connected, do connect for ".\@args.", ".dumper($args[0]) if DEBUG;
my ($c,$t);
weaken( $self->{waitingcb}{int $cb} = $cb ) if $cb;
weaken( $self );
# This rely on correct event invocation order of Object::Event.
# If this could change, I'll add own queue
$c = $self->reg_cb(
connected => sub {
shift->unreg_me;
view release on metacpan or search on metacpan
lib/AnyEvent/MySQL.pm view on Meta::CPAN
use warnings;
use AE;
use AnyEvent::Socket;
use AnyEvent::Handle;
use Scalar::Util qw(weaken dualvar);
use Guard;
# connection state
use constant {
BUSY_CONN => 1,
lib/AnyEvent/MySQL.pm view on Meta::CPAN
$param->{host} = '/unix';
$param->{port} = $sock;
}
warn "Connecting to $param->{host}:$param->{port} ...";
weaken( my $wdbh = $dbh );
$dbh->{_}[CONNi] = tcp_connect($param->{host}, $param->{port}, sub {
my $fh = shift;
if( !$fh ) {
warn "Connect to $param->{host}:$param->{port} fail: $! retry later.";
undef $wdbh->{_}[CONNi];
lib/AnyEvent/MySQL.pm view on Meta::CPAN
my $dbh = shift;
$dbh->{_}[CONN_STATEi] = IDLE_CONN;
$dbh->{_}[ERRi] = $AnyEvent::MySQL::err = undef;
$dbh->{_}[ERRSTRi] = $AnyEvent::MySQL::errstr = undef;
$dbh->{_}[FALLBACKi] = undef;
weaken( my $wdbh = $dbh );
if( !$dbh->{_}[HDi] ) {
_reconnect($dbh);
return;
}
lib/AnyEvent/MySQL.pm view on Meta::CPAN
sub prepare {
my $dbh = $_[0];
my $sth = AnyEvent::MySQL::st->new(@_);
push @{$dbh->{_}[STi]}, $sth;
weaken($dbh->{_}[STi][-1]);
return $sth;
}
=head2 $dbh->begin_work([$cb->($rv)])
lib/AnyEvent/MySQL.pm view on Meta::CPAN
package AnyEvent::MySQL::st;
use strict;
use warnings;
use Scalar::Util qw(weaken);
use constant {
DBHi => 0,
IDi => 1,
PARAMi => 2,
view release on metacpan or search on metacpan
lib/AnyEvent/Net/MPD.pm view on Meta::CPAN
sub get { shift->send( @_ )->recv }
sub until {
my ($self, $name, $check, $cb) = @_;
weaken $self;
my $wrapper;
$wrapper = sub {
if ($check->(@_)) {
$self->unsubscribe($name => $wrapper);
$cb->(@_);
view release on metacpan or search on metacpan
lib/AnyEvent/Onkyo.pm view on Meta::CPAN
use base 'Device::Onkyo';
use AnyEvent::Handle;
use AnyEvent::SerialPort;
use Carp qw/croak carp/;
use Sub::Name;
use Scalar::Util qw/weaken/;
use constant {
DEBUG => $ENV{ANYEVENT_ONKYO_DEBUG},
};
lib/AnyEvent/Onkyo.pm view on Meta::CPAN
sub command {
my $self = shift;
my $cv = AnyEvent->condvar;
my $weak_cv = $cv;
weaken $weak_cv;
$self->SUPER::command(@_, subname 'command_cb' => sub {
$weak_cv->send() if ($weak_cv);
});
return $cv;
}
lib/AnyEvent/Onkyo.pm view on Meta::CPAN
sub _handle_setup {
my $self = shift;
my $handle = $self->{handle};
my $weak_self = $self;
weaken $weak_self;
$handle->on_error(subname('on_error' => sub {
my ($hdl, $fatal, $msg) = @_;
print STDERR $hdl.": error $msg\n" if DEBUG;
$hdl->destroy;
lib/AnyEvent/Onkyo.pm view on Meta::CPAN
sub _open_condvar {
my $self = shift;
print STDERR $self."->open_condvar\n" if DEBUG;
my $cv = AnyEvent->condvar;
my $weak_self = $self;
weaken $weak_self;
$cv->cb(subname 'open_cb' => sub {
print STDERR "start cb ", $weak_self->{handle}, " @_\n" if DEBUG;
$weak_self->_handle_setup();
$weak_self->_write_now();
lib/AnyEvent/Onkyo.pm view on Meta::CPAN
sub anyevent_read_type {
my ($handle, $cb, $self) = @_;
my $weak_self = $self;
weaken $weak_self;
subname 'anyevent_read_type_reader' => sub {
my ($handle) = @_;
my $rbuf = \$handle->{rbuf};
while (1) { # read all message from the buffer
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
lib/AnyEvent/Plackup.pm view on Meta::CPAN
);
use AnyEvent;
use Twiggy::Server;
use Net::EmptyPort qw(empty_port);
use Scalar::Util qw(weaken);
use Carp;
use Class::Accessor::Lite (
ro => [
'host', 'port',
lib/AnyEvent/Plackup.pm view on Meta::CPAN
}
sub _run {
my $self = shift;
weaken $self;
$self->{ready_cv} = AE::cv;
my $app = $self->{app} || $self->_mk_default_app;
lib/AnyEvent/Plackup.pm view on Meta::CPAN
my $self = shift;
$self->{request_cv} = AE::cv;
$self->{request_queue} = [];
weaken $self;
require AnyEvent::Plackup::Request;
return sub {
my ($env) = @_;
view release on metacpan or search on metacpan
Porttracker.pm view on Meta::CPAN
queue => [], # initially queue everything
@_,
}, $class;
{
Scalar::Util::weaken (my $self = $self);
$self->{hdl} = new AnyEvent::Handle
connect => [$self->{host}, $self->{port} || "porttracker=55"],
on_error => sub {
$self->error ($_[2]);
view release on metacpan or search on metacpan
lib/AnyEvent/RFXCOM/Base.pm view on Meta::CPAN
};
use AnyEvent::Handle;
use AnyEvent::Socket;
use Sub::Name;
use Scalar::Util qw/weaken/;
sub _open_condvar {
my $self = shift;
my $cv = AnyEvent->condvar;
my $weak_self = $self;
weaken $weak_self;
$cv->cb(subname 'open_cb' => sub {
my $fh = $_[0]->recv;
print STDERR "start cb $fh @_\n" if DEBUG;
my $handle; $handle =
view release on metacpan or search on metacpan
lib/AnyEvent/RabbitMQ/Fork.pm view on Meta::CPAN
=cut
use Moo;
use Types::Standard qw(CodeRef Str HashRef InstanceOf Bool Object);
use Scalar::Util qw(weaken);
use Carp qw(croak);
use File::ShareDir qw(dist_file);
use constant DEFAULT_AMQP_SPEC =>
dist_file('AnyEvent-RabbitMQ', 'fixed_amqp0-9-1.xml');
lib/AnyEvent/RabbitMQ/Fork.pm view on Meta::CPAN
init_arg => undef,
);
sub _build_rpc {
my $self = shift;
weaken(my $wself = $self);
return AnyEvent::Fork->new #
->require($self->worker_class) #
->send_arg($self->worker_class, verbose => $self->verbose) #
->AnyEvent::Fork::RPC::run(
view release on metacpan or search on metacpan
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
use Scalar::Util qw(refaddr);
use List::MoreUtils qw(none);
use Devel::GlobalDestruction;
use File::ShareDir;
use Readonly;
use Scalar::Util qw/ weaken /;
require Data::Dumper;
sub Dumper {
local $Data::Dumper::Terse = 1;
local $Data::Dumper::Indent = 1;
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
warn 'connect to ', $args{host}, ':', $args{port}, '...', "\n";
}
$self->{_state} = _ST_OPENING;
weaken(my $weak_self = $self);
my $conn; $conn = AnyEvent::Socket::tcp_connect(
$args{host},
$args{port},
sub {
undef $conn;
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
sub _read_loop {
my ($self, $close_cb, $failure_cb,) = @_;
return if !defined $self->{_handle}; # called on_error
weaken(my $weak_self = $self);
$self->{_handle}->push_read(chunk => 8, sub {
my $self = $weak_self or return;
my $data = $_[1];
my $stack = $_[1];
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
sub _tune {
my $self = shift;
my %args = @_;
weaken(my $weak_self = $self);
$self->_push_read_and_valid(
'Connection::Tune',
sub {
my $self = $weak_self or return;
my $frame = shift;
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
my $close_cb = $args{on_close};
my $failure_cb = $args{on_read_failure};
my $last_recv = 0;
my $idle_cycles = 0;
weaken(my $weak_self = $self);
my $timer_cb = sub {
my $self = $weak_self or return;
if ($self->{_heartbeat_recv} != $last_recv) {
$last_recv = $self->{_heartbeat_recv};
$idle_cycles = 0;
view release on metacpan or search on metacpan
lib/AnyEvent/Redis/Federated.pm view on Meta::CPAN
use warnings;
use AnyEvent::Redis;
use AnyEvent;
use Set::ConsistentHash; # for hash ring logic
use Digest::MD5 qw(md5); # for hashing keys
use Scalar::Util qw(weaken);
use List::Util qw(shuffle);
our $VERSION = "0.08";
# keep a global object cache that will contain weak references to
lib/AnyEvent/Redis/Federated.pm view on Meta::CPAN
bless $self, $class;
# cache it for later use
if ($self->{tag}) {
$object_cache{$self->{tag}} = $self;
weaken($object_cache{$self->{tag}});
}
return $self;
}
view release on metacpan or search on metacpan
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
our $VERSION = '1.62';
use AnyEvent;
use AnyEvent::Handle;
use Encode qw( find_encoding is_utf8 );
use Scalar::Util qw( looks_like_number weaken );
use Digest::SHA qw( sha1_hex );
use Carp qw( croak );
my %ERROR_CODES;
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _get_on_prepare {
my $self = shift;
weaken( $self );
return sub {
if ( defined $self->{connection_timeout} ) {
return $self->{connection_timeout};
}
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _get_on_connect {
my $self = shift;
weaken( $self );
return sub {
$self->{_connected} = 1;
unless ( defined $self->{password} ) {
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _get_on_connect_error {
my $self = shift;
weaken( $self );
return sub {
my $err_msg = pop;
$self->_disconnect(
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _get_on_rtimeout {
my $self = shift;
weaken( $self );
return sub {
if ( @{ $self->{_processing_queue} } ) {
$self->_disconnect( 'Read timed out.', E_READ_TIMEDOUT );
}
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _get_on_eof {
my $self = shift;
weaken( $self );
return sub {
$self->_disconnect( 'Connection closed by remote host.',
E_CONN_CLOSED_BY_REMOTE_HOST );
};
}
sub _get_handle_on_error {
my $self = shift;
weaken( $self );
return sub {
my $err_msg = pop;
$self->_disconnect( $err_msg, E_IO );
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _get_on_read {
my $self = shift;
weaken( $self );
my $str_len;
my @bufs;
my $bufs_num = 0;
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _auth {
my $self = shift;
weaken( $self );
$self->{_auth_st} = S_IN_PROGRESS;
$self->_push_write(
{ kwd => 'auth',
lib/AnyEvent/Redis/RipeRedis.pm view on Meta::CPAN
}
sub _select_db {
my $self = shift;
weaken( $self );
$self->{_select_db_st} = S_IN_PROGRESS;
$self->_push_write(
{ kwd => 'select',
view release on metacpan or search on metacpan
lib/AnyEvent/Redis.pm view on Meta::CPAN
use AnyEvent::Handle;
use AnyEvent::Socket;
use AnyEvent::Redis::Protocol;
use Carp qw( croak confess );
use Encode ();
use Scalar::Util qw(weaken);
our $AUTOLOAD;
sub new {
my ($class, %args) = @_;
lib/AnyEvent/Redis.pm view on Meta::CPAN
$cv ||= AE::cv;
push @{$self->{connect_queue}}, [ $cv, @_ ];
}
return $cv if $self->{sock};
weaken $self;
$self->{sock} = tcp_connect $self->{host}, $self->{port}, sub {
my $fh = shift
or do {
my $err = "Can't connect Redis server: $!";
lib/AnyEvent/Redis.pm view on Meta::CPAN
: $_ } @_))
. "\r\n";
warn $send if DEBUG;
# $self is weakened to avoid leaks, hold on to a strong copy
# controlled via a CV.
my $cmd_cv = AE::cv;
$cmd_cv->cb(sub {
my $strong_self = $self;
});
view release on metacpan or search on metacpan
lib/AnyEvent/Retry.pm view on Meta::CPAN
use MooseX::Types::Common::Numeric qw(PositiveNum);
use AnyEvent::Retry::Types qw(Interval);
use AnyEvent;
use Try::Tiny;
use Scalar::Util qw(weaken);
use true;
use namespace::autoclean;
has 'after' => (
lib/AnyEvent/Retry.pm view on Meta::CPAN
# set a timer to call handle_tick in the future
sub set_timer {
my ($self, $time, $i) = @_;
return $self->handle_tick($i) if $time <= 0;
weaken $self;
$self->_set_timer(
AnyEvent->timer( after => $time, cb => sub {
$self->kill_timer;
$self->handle_tick($i);
}),
lib/AnyEvent/Retry.pm view on Meta::CPAN
# start the user's code running, with a continuation-passing-style
# callback to call when the result is ready
sub run_code {
my ($self) = @_;
# we weaken $self here so that if the user does "undef $retry", we
# DEMOLISH the object and silently discard the results of the
# running code. feel free to subclass if want to keep the class
# alive arbitrarily.
weaken $self;
my $success = sub {
my $result = shift;
return unless defined $self;
$self->handle_result(($result ? 1 : 0), 'success', $result);
view release on metacpan or search on metacpan
lib/AnyEvent/RetryTimer.pm view on Meta::CPAN
package AnyEvent::RetryTimer;
use common::sense;
use Scalar::Util qw/weaken/;
use AnyEvent;
our $VERSION = '0.1';
=head1 NAME
lib/AnyEvent/RetryTimer.pm view on Meta::CPAN
};
bless $self, $class;
my $rself = $self;
weaken $self;
$self->{timer} = AE::timer 0, 0, sub {
delete $self->{timer};
$self->{on_retry}->($self) if $self;
};
lib/AnyEvent/RetryTimer.pm view on Meta::CPAN
=cut
sub retry {
my ($self) = @_;
weaken $self;
return if $self->{timer};
if ($self->{backoff} eq 'exponential') {
my $r;
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
use AnyEvent::RipeRedis;
use AnyEvent::RipeRedis::Error;
use AnyEvent::Socket;
use List::MoreUtils qw( bsearch );
use Scalar::Util qw( looks_like_number weaken );
use Carp qw( croak );
my %ERROR_CODES;
BEGIN {
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
my $self = shift;
$self->{_init_state} = S_IN_PROGRESS;
undef $self->{_refresh_timer};
weaken($self);
$self->_discover_cluster(
sub {
my $err = $_[1];
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
$self->{_nodes_pool} = \%nodes_pool;
$nodes = [ keys %nodes_pool ];
}
weaken($self);
$self->_execute(
{ name => 'cluster_state',
args => [],
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
my $self = shift;
my $cb = shift;
my $nodes = $self->_nodes( undef, $self->{allow_slaves} );
weaken($self);
$self->_execute(
{ name => 'command',
args => [],
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
sub _create_on_node_connect {
my $self = shift;
my $host = shift;
my $port = shift;
weaken($self);
return sub {
if ( defined $self->{on_node_connect} ) {
$self->{on_node_connect}->( $host, $port );
}
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
sub _create_on_node_disconnect {
my $self = shift;
my $host = shift;
my $port = shift;
weaken($self);
return sub {
if ( defined $self->{on_node_disconnect} ) {
$self->{on_node_disconnect}->( $host, $port );
}
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
sub _create_on_node_error {
my $self = shift;
my $host = shift;
my $port = shift;
weaken($self);
return sub {
my $err = shift;
if ( defined $self->{on_node_error} ) {
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
sub _prepare {
my $self = shift;
my $cmd_name = shift;
my $args = shift;
weaken($self);
my $cbs;
if ( ref( $args->[-1] ) eq 'HASH' ) {
$cbs = pop @{$args};
}
lib/AnyEvent/RipeRedis/Cluster.pm view on Meta::CPAN
my $cmd_name = $cmd->{name} eq 'cluster_state'
? 'cluster_info'
: $cmd->{name};
weaken($self);
$node->execute( $cmd_name, @{ $cmd->{args} },
{ on_reply => sub {
my $reply = shift;
my $err = shift;
view release on metacpan or search on metacpan
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
use AnyEvent::RipeRedis::Error;
use AnyEvent;
use AnyEvent::Handle;
use Scalar::Util qw( looks_like_number weaken );
use Digest::SHA qw( sha1_hex );
use Carp qw( croak );
my %ERROR_CODES;
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _create_on_prepare {
my $self = shift;
weaken($self);
return sub {
if ( defined $self->{connection_timeout} ) {
return $self->{connection_timeout};
}
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _create_on_connect {
my $self = shift;
weaken($self);
return sub {
$self->{_connected} = 1;
unless ( defined $self->{password} ) {
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _create_on_connect_error {
my $self = shift;
weaken($self);
return sub {
my $err_msg = pop;
my $err = _new_error(
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _create_on_rtimeout {
my $self = shift;
weaken($self);
return sub {
if ( @{ $self->{_processing_queue} } ) {
my $err = _new_error( 'Read timed out.', E_READ_TIMEDOUT );
$self->_disconnect($err);
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _create_on_eof {
my $self = shift;
weaken($self);
return sub {
my $err = _new_error( 'Connection closed by remote host.',
E_CONN_CLOSED_BY_REMOTE_HOST );
$self->_disconnect($err);
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _create_on_handle_error {
my $self = shift;
weaken($self);
return sub {
my $err_msg = pop;
my $err = _new_error( $err_msg, E_IO );
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _create_on_read {
my $self = shift;
weaken($self);
my $str_len;
my @bufs;
my $bufs_num = 0;
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
args => $args,
%{$cbs},
};
unless ( defined $cmd->{on_reply} ) {
weaken($self);
$cmd->{on_reply} = sub {
my $err = $_[1];
if ( defined $err ) {
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
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};
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _auth {
my $self = shift;
weaken($self);
$self->{_auth_state} = S_IN_PROGRESS;
$self->_push_write(
{ name => 'auth',
kwds => ['auth'],
lib/AnyEvent/RipeRedis.pm view on Meta::CPAN
}
sub _select_database {
my $self = shift;
weaken($self);
$self->{_db_selection_state} = S_IN_PROGRESS;
$self->_push_write(
{ name => 'select',
kwds => ['select'],
view release on metacpan or search on metacpan
lib/AnyEvent/SOCKS/Client.pm view on Meta::CPAN
use AnyEvent::Util qw/guard/;
use AnyEvent::Socket qw/tcp_connect parse_ipv4 format_ipv4 parse_ipv6 format_ipv6/;
use AnyEvent::Handle ;
use AnyEvent::Log ;
use Scalar::Util qw/weaken/;
require Exporter;
our $VERSION = '0.051';
our @ISA = qw/Exporter/;
our @EXPORT_OK = qw/tcp_connect_via/;
lib/AnyEvent/SOCKS/Client.pm view on Meta::CPAN
pre_cb => $pre_cb,
}, __PACKAGE__ ;
$con->connect;
if( defined wantarray ){ # not void
weaken( $con );
return guard{
AE::log "debug" => "Guard triggered" ;
if( ref $con eq __PACKAGE__ ){
undef $con->{c_cb};
$con->DESTROY;
view release on metacpan or search on metacpan
lib/AnyEvent/SSH2.pm view on Meta::CPAN
CHAN_INPUT_CLOSED CHAN_INPUT_WAIT_DRAIN );
use Net::SSH::Perl::Cipher;
use Net::SSH::Perl::AuthMgr;
use Net::SSH::Perl::Comp;
use Net::SSH::Perl::Util qw(:hosts);
use Scalar::Util qw(blessed weaken);
use Carp qw( croak );
use base qw( Net::SSH::Perl );
our $VERSION = '0.04';
lib/AnyEvent/SSH2.pm view on Meta::CPAN
#no strict "refs";
*Net::SSH::Perl::AuthMgr::new = sub {
my $class = shift;
my $ssh = shift;
my $amgr = bless { ssh => $ssh }, $class;
weaken $amgr->{ssh};
$amgr;
};
*Net::SSH::Perl::AuthMgr::run = sub {
my $amgr = shift;
my $cb = pop @_;
view release on metacpan or search on metacpan
lib/AnyEvent/Semaphore.pm view on Meta::CPAN
my ($sem) = @_;
my $watchers = $sem->{watchers};
my $w = [@_];
bless $w, 'AnyEvent::Semaphore::Watcher';
push @{$watchers}, $w;
Scalar::Util::weaken($watchers->[-1]);
&AE::postpone($sem->{schedule_cb});
$w;
}
sub _schedule {
lib/AnyEvent/Semaphore.pm view on Meta::CPAN
my $sem = $watcher->[0];
my $holes = ++$sem->{holes};
my $watchers = $sem->{watchers};
if ($holes > 100 and $holes * 2 > @$watchers) {
@{$sem->{watchers}} = grep defined, @$watchers;
Scalar::Util::weaken $_ for @$watchers;
$sem->{holes} = 0;
}
}
}
view release on metacpan or search on metacpan
lib/AnyEvent/Stomper.pm view on Meta::CPAN
use AnyEvent::Stomper::Frame;
use AnyEvent::Stomper::Error;
use AnyEvent;
use AnyEvent::Handle;
use Scalar::Util qw( looks_like_number weaken );
use List::Util qw( max );
use List::MoreUtils qw( bsearch_index );
use Carp qw( croak );
my %ERROR_CODES;
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
sub _create_on_prepare {
my $self = shift;
weaken($self);
return sub {
if ( defined $self->{connection_timeout} ) {
return $self->{connection_timeout};
}
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
sub _create_on_connect {
my $self = shift;
weaken($self);
return sub {
$self->{_connected} = 1;
$self->_login;
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
sub _create_on_connect_error {
my $self = shift;
weaken($self);
return sub {
my $err_msg = pop;
my $err = _new_error(
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
sub _create_on_wtimeout {
my $self = shift;
weaken($self);
return sub {
$self->{_handle}->push_write(EOL);
};
}
sub _create_on_rtimeout {
my $self = shift;
weaken($self);
return sub {
my $err = _new_error( 'Read timed out.', E_READ_TIMEDOUT );
$self->_disconnect($err);
};
}
sub _create_on_eof {
my $self = shift;
weaken($self);
return sub {
my $err = _new_error( 'Connection closed by remote host.',
E_CONN_CLOSED_BY_REMOTE_HOST );
$self->_disconnect($err);
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
sub _create_on_handle_error {
my $self = shift;
weaken($self);
return sub {
my $err_msg = pop;
my $err = _new_error( $err_msg, E_IO );
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
sub _create_on_drain {
my $self = shift;
weaken($self);
return sub {
return unless @{ $self->{_write_queue} };
$self->{_temp_write_queue} = $self->{_write_queue};
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
sub _create_on_read {
my $self = shift;
weaken($self);
my $cmd_name;
my $headers;
return sub {
lib/AnyEvent/Stomper.pm view on Meta::CPAN
headers => \%headers,
%params,
};
unless ( defined $cmd->{on_receipt} ) {
weaken($self);
$cmd->{on_receipt} = sub {
my $receipt = shift;
my $err = shift;
lib/AnyEvent/Stomper.pm view on Meta::CPAN
else {
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};
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
if ( defined $self->{vhost} ) {
$cmd_headers{host} = $self->{vhost};
}
weaken($self);
$self->{_login_state} = S_IN_PROGRESS;
$self->_push_write(
{ name => 'CONNECT',
headers => \%cmd_headers,
view release on metacpan or search on metacpan
lib/AnyEvent/Task/Client.pm view on Meta::CPAN
sub populate_workers {
my ($self) = @_;
Scalar::Util::weaken($self);
return if $self->{total_workers} >= $self->{max_workers};
my $workers_to_create = $self->{min_workers} - $self->{total_workers};
if ($workers_to_create <= 0) {
lib/AnyEvent/Task/Client.pm view on Meta::CPAN
my $checkout = shift @{$self->{pending_checkouts}};
$checkout->{worker} = $worker;
$self->{workers_to_checkouts}->{0 + $worker} = $checkout;
Scalar::Util::weaken($self->{workers_to_checkouts}->{0 + $worker});
$checkout->_try_to_fill_requests;
return $self->try_to_fill_pending_checkouts;
}
view release on metacpan or search on metacpan
lib/AnyEvent/Tickit.pm view on Meta::CPAN
use base qw( Tickit );
sub _capture_weakself {
my ($self, $method) = @_;
Scalar::Util::weaken $self;
my $cb = $self->can($method);
return $cb->( $self, @_ );
}
view release on metacpan or search on metacpan
lib/AnyEvent/Timer/Cron.pm view on Meta::CPAN
our $VERSION = '0.002000';
$VERSION = eval $VERSION;
use AnyEvent;
use Scalar::Util qw(weaken);
use Safe::Isa;
use DateTime;
use DateTime::Event::Cron;
use namespace::clean;
lib/AnyEvent/Timer/Cron.pm view on Meta::CPAN
$self->create_timer;
}
sub create_timer {
my $self = shift;
weaken $self;
my $now = DateTime->from_epoch(epoch => AnyEvent->now);
$now->set_time_zone( $self->time_zone ) if $self->time_zone;
my $next = $self->next_event($now);
return
if not $next;
view release on metacpan or search on metacpan
lib/AnyEvent/Twitter/Stream.pm view on Meta::CPAN
}
my $self = bless {}, $class;
{
Scalar::Util::weaken(my $self = $self);
my $set_timeout = $timeout
? sub { $self->{timeout} = AE::timer($timeout, 0, sub { $on_error->('timeout') }) }
: sub {};
view release on metacpan or search on metacpan
lib/AnyEvent/WebSocket/Connection.pm view on Meta::CPAN
);
sub BUILD
{
my $self = shift;
Scalar::Util::weaken $self;
my @temp_messages = ();
my $are_callbacks_supposed_to_be_ready = 0;
my $finish = sub {