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 {
view release on metacpan or search on metacpan
lib/AnyEvent/Worker.pm view on Meta::CPAN
my $rbuf;
my @caller = (caller)[1,2]; # the "default" caller
{
Scalar::Util::weaken (my $self = $self);
$self->{rw} = AnyEvent->io (fh => $client, poll => "r", cb => sub {
return unless $self;
$self->{last_activity} = AnyEvent->now;
lib/AnyEvent/Worker.pm view on Meta::CPAN
# we need to re-set the timeout watcher
$self->{tw} = AnyEvent->timer (
after => $self->{last_activity} + $self->{timeout} - AnyEvent->now,
cb => $self->{tw_cb},
);
Scalar::Util::weaken $self;
}
} else {
# no timeout check wanted, or idle
undef $self->{tw};
}
view release on metacpan or search on metacpan
lib/AnyEvent/XMPP/Client.pm view on Meta::CPAN
=cut
sub update_connections {
my ($self) = @_;
Scalar::Util::weaken $self;
for (values %{$self->{accounts}}) {
my $acc = $_;
if (!$acc->is_connected && !$self->{prep_connections}->{$acc->bare_jid}) {
view release on metacpan or search on metacpan
sv_ref||5.015004|
sv_replace|||
sv_report_used|||
sv_resetpvn|||
sv_reset|||
sv_rvweaken||5.006000|
sv_sethek|||
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
view release on metacpan or search on metacpan
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 3);
PUSHs((SV*)userp); /* XXX This is a weakened reference, will it ever be undef? */
PUSHs(sv_2mortal(newSViv(s)));
PUSHs(sv_2mortal(newSViv(what)));
PUTBACK;
call_sv(MY_CXT.watchset_fn, G_DISCARD | G_VOID);
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 2);
PUSHs((SV*)userp); /* XXX This is a weakened reference, will it ever be undef? */
PUSHs(sv_2mortal(newSViv(timeout_ms)));
PUTBACK;
call_sv(MY_CXT.timerset_fn, G_DISCARD | G_VOID);
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), "AnyEvent::YACurl", (void*)client);
/* XXX When we destroy the client, do we pass undefs to the timer/watch functions? */
client->weak_self_ref = newSVsv(ST(0));
sv_rvweaken(client->weak_self_ref);
client->multi = curl_multi_init();
curl_multi_setopt(client->multi, CURLMOPT_SOCKETFUNCTION, mcurl_socket_callback);
curl_multi_setopt(client->multi, CURLMOPT_TIMERFUNCTION, mcurl_timer_callback);
curl_multi_setopt(client->multi, CURLMOPT_SOCKETDATA, (void*)client->weak_self_ref);