view release on metacpan or search on metacpan
lib/AnyEvent/Emitter.pm view on Meta::CPAN
package AnyEvent::Emitter;
use strict;
use Scalar::Util qw(blessed weaken);
our $VERSION = 0.02;
use constant DEBUG => $ENV{EMITTER_DEBUG} || 0;
lib/AnyEvent/Emitter.pm view on Meta::CPAN
sub on { push @{$_[0]{events}{$_[1]}}, $_[2] and return $_[2] }
sub once {
my ($self, $name, $cb) = @_;
weaken $self;
my $wrapper;
$wrapper = sub {
$self->unsubscribe($name => $wrapper);
$cb->(@_);
};
$self->on($name => $wrapper);
weaken $wrapper;
return $wrapper;
}
sub subscribers { shift->{events}{shift()} || [] }
view release on metacpan or search on metacpan
lib/AnyEvent/eris/Client.pm view on Meta::CPAN
# in second thought, this should just be removed because
# it's meant for internal manual buffering, which we don't need
$block
and AE::log fatal => 'Block option not supported';
Scalar::Util::weaken( my $inner_self = $self );
$self->{'_client'} ||= tcp_connect $addr, $port, sub {
my ($fh) = @_
or AE::log fatal => "Connect failed: $!";
view release on metacpan or search on metacpan
lib/AnyEvent/FCGI.pm view on Meta::CPAN
use strict;
use warnings;
our $VERSION = '0.04';
use Scalar::Util qw/weaken refaddr/;
use AnyEvent;
use AnyEvent::Socket;
use AnyEvent::Handle;
use AnyEvent::FCGI::Connection;
lib/AnyEvent/FCGI.pm view on Meta::CPAN
connections => {},
on_request_cb => $params{on_request},
}, $class;
my $fcgi = $self;
weaken($fcgi);
$params{socket} ||= $params{unix};
$self->{server} = tcp_server(
$params{socket} ? 'unix/' : $params{host},
view release on metacpan or search on metacpan
prefix => "..:aefcpid:$rand:",
idseq => "a0",
}, $class;
{
Scalar::Util::weaken (my $self = $self);
$self->{kw} = AE::timer $self->{keepalive}, $self->{keepalive}, sub {
$self->{hdl}->push_write ("\n");
};
on_error => sub {
$self->fatal ($_[2]);
},
;
Scalar::Util::weaken ($self->{hdl}{fcp} = $self);
}
$self->send_msg (client_hello =>
name => $self->{name},
expected_version => "2.0",
($ok, $err) = @$ok;
} elsif (UNIVERSAL::isa $ok, AnyEvent::CondVar::) {
$err = sub { $ok->croak ($_[0]{extra_description}) };
} else {
my $bt = Carp::longmess "AnyEvent::FCP request $name";
Scalar::Util::weaken (my $self = $_[0]);
my $args = [@_]; shift @$args;
$err = sub {
if ($self->{on_failure}) {
$self->{on_failure}($self, $name, $args, $bt, $_[0]);
} else {
view release on metacpan or search on metacpan
lib/AnyEvent/Feed.pm view on Meta::CPAN
use Encode;
use XML::Feed;
use MIME::Base64;
use AnyEvent::HTTP;
use Digest::SHA1 qw/sha1_base64/;
use Scalar::Util qw/weaken/;
our $VERSION = '0.3';
=head1 NAME
lib/AnyEvent/Feed.pm view on Meta::CPAN
unless (defined $self->{on_fetch}) {
croak "no 'on_fetch' callback given!";
}
my $wself = $self;
weaken $wself;
$self->{timer_cb} = sub {
$wself->fetch (sub {
my ($self, $e, $f, $err) = @_;
view release on metacpan or search on metacpan
lib/AnyEvent/Filesys/Notify/Role/Inotify2.pm view on Meta::CPAN
use Carp;
use Path::Iterator::Rule;
our $VERSION = '1.23';
# use Scalar::Util qw(weaken); # Attempt to address RT#57104, but alas...
sub _init {
my $self = shift;
my $inotify = Linux::Inotify2->new()
lib/AnyEvent/Filesys/Notify/Role/Inotify2.pm view on Meta::CPAN
# Need to add all the subdirs to the watch list, this will catch
# modifications to files too.
my $old_fs = $self->_old_fs;
my @dirs = grep { $old_fs->{$_}->{is_dir} } keys %$old_fs;
# weaken $self; # Attempt to address RT#57104, but alas...
for my $dir (@dirs) {
$inotify->watch(
$dir,
IN_MODIFY | IN_CREATE | IN_DELETE | IN_DELETE_SELF |
view release on metacpan or search on metacpan
lib/AnyEvent/Filesys/Watcher/FSEvents.pm view on Meta::CPAN
our $VERSION = 'v0.1.1'; # VERSION
use AnyEvent;
use Mac::FSEvents;
use Scalar::Util qw(weaken);
use Config;
use base qw(AnyEvent::Filesys::Watcher);
# Needed for counting unset bits.
lib/AnyEvent/Filesys/Watcher/FSEvents.pm view on Meta::CPAN
my $watcher = AE::io $self->{__mac_fh}, 0, sub {
if (my @raw_events = $fs_monitor->read_events) {
$alter_ego->_processEvents(@raw_events);
}
};
weaken $alter_ego;
$self->_watcher($watcher);
return $self;
}
view release on metacpan or search on metacpan
;
++$nidle;
Array::Heap::push_heap_idx @pool, $proc;
Scalar::Util::weaken $proc;
};
$stop_worker = sub {
my $proc = shift;
view release on metacpan or search on metacpan
lib/AnyEvent/ForkManager.pm view on Meta::CPAN
use warnings;
our $VERSION = '0.07';
use AnyEvent;
use Scalar::Util qw/weaken/;
use POSIX qw/WNOHANG/;
use Time::HiRes ();
use Class::Accessor::Lite 0.04 (
ro => [
lib/AnyEvent/ForkManager.pm view on Meta::CPAN
}
sub _create_callback {
my($self, @args) = @_;
weaken($self);
return sub {
my ($pid, $status) = @_;
delete $self->running_worker->{$pid};
delete $self->process_cb->{$pid};
$self->_run_cb('on_finish' => $pid, $status, @args);
lib/AnyEvent/ForkManager.pm view on Meta::CPAN
else {
die 'cannot call.' if $self->wait_async;
my $super = $self->on_finish;
weaken($self);
$self->on_finish(
sub {
$super->(@_);
if ($self->num_workers == 0 and $self->num_queues == 0) {
$self->$cb;
view release on metacpan or search on metacpan
lib/AnyEvent/ForkObject.pm view on Meta::CPAN
use Carp;
use AnyEvent;
use AnyEvent::Util;
use AnyEvent::Handle;
use Scalar::Util qw(weaken blessed reftype);
use POSIX;
use IO::Handle;
use AnyEvent::Serialize qw(:all);
use AnyEvent::Tools qw(mutex);
use Devel::GlobalDestruction;
lib/AnyEvent/ForkObject.pm view on Meta::CPAN
# parent
$self->{mutex} = mutex;
close $s2;
fh_nonblocking $s1, 1;
{
weaken(my $self = $self);
$self->{handle} = new AnyEvent::Handle
fh => $s1,
on_error => sub {
return unless $self;
return if $self->{destroyed};
lib/AnyEvent/ForkObject.pm view on Meta::CPAN
my $args = $opts{args} || [];
my $wantarray = $opts{wantarray};
my $require = $opts{require};
$wantarray = 0 unless exists $opts{wantarray};
weaken $self;
$self->{mutex}->lock(sub {
my ($guard) = @_;
return unless $self;
return if $self->{destroyed};
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
}
AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
{
Scalar::Util::weaken (my $self = $self);
$self->{rw} = AE::io $self->{fh}, 0, sub {
my $len = sysread $self->{fh}, $self->{rbuf}, 256, length $self->{rbuf};
defined $len || $self->eof;
view release on metacpan or search on metacpan
my ($self) = @_;
delete $self->{fh};
delete $self->{command};
Scalar::Util::weaken $self;
$self->{retry_w} = AnyEvent->timer (after => 1, cb => sub {
delete $self->{retry_w};
$self->connect;
});
}
}
$self->interval_timer;
});
Scalar::Util::weaken $self;
}
sub connect {
my ($self) = @_;
} else {
$self->event ("error");
}
};
Scalar::Util::weaken $self;
}
sub drain_wbuf {
my ($self) = @_;
$self->{stretch} = $option{stretch} || 1;
$self->{compress} = $option{compress};
$self->{imterval} /= $self->{stretch};
Scalar::Util::weaken $self;
$self->{replay_cb} = sub {
my $line = <$fh>;
if (2 > length $line) {
view release on metacpan or search on metacpan
t/02-Slot.t view on Meta::CPAN
# Log::Log4perl->easy_init($DEBUG);
use Gear;
use AnyEvent;
use AnyEvent::Gearman;
use AnyEvent::Gearman::WorkerPool::Slot;
use Scalar::Util qw(weaken);
my $port = '9955';
my @js = ("localhost:$port");
my $cv = AE::cv;
my $t = AE::timer 10,0,sub{ $cv->send('timeout')};
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
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/HTTPD/SendMultiHeaderPatch.pm view on Meta::CPAN
use AnyEvent::HTTPD;
use AnyEvent::HTTPD::Util;
use AnyEvent::HTTPD::HTTPConnection;
use Scalar::Util qw(weaken);
push @AnyEvent::HTTPD::Util::EXPORT, qw(header_add header_gets);
*AnyEvent::HTTPD::Util::header_add = sub {
my ($hdrs, $name, $value) = @_;
lib/AnyEvent/HTTPD/SendMultiHeaderPatch.pm view on Meta::CPAN
$self->response_done;
return;
}
if (ref ($content) eq 'CODE') {
weaken $self;
my $chunk_cb = sub {
my ($chunk) = @_;
return 0 unless defined ($self) && defined ($self->{hdl}) && !$self->{disconnected};
view release on metacpan or search on metacpan
lib/AnyEvent/HTTPD.pm view on Meta::CPAN
package AnyEvent::HTTPD;
use common::sense;
use Scalar::Util qw/weaken/;
use URI;
use AnyEvent::HTTPD::Request;
use AnyEvent::HTTPD::Util;
use base qw/AnyEvent::HTTPD::HTTPServer/;
lib/AnyEvent/HTTPD.pm view on Meta::CPAN
$self->reg_cb (
connect => sub {
my ($self, $con) = @_;
weaken $self;
$self->{conns}->{$con} = $con->reg_cb (
request => sub {
my ($con, $meth, $url, $hdr, $cont) = @_;
#d# warn "REQUEST: $meth, $url, [$cont] " . join (',', %$hdr) . "\n";
lib/AnyEvent/HTTPD.pm view on Meta::CPAN
$cont = parse_urlencoded ($url->query);
}
if ( scalar grep { $meth eq $_ } @{ $self->{allowed_methods} } ) {
weaken $con;
$self->handle_app_req (
$meth, $url, $hdr, $cont, $con->{host}, $con->{port},
sub {
$con->response (@_) if $con;
view release on metacpan or search on metacpan
lib/AnyEvent/Handle/Throttle.pm view on Meta::CPAN
}
sub start_read {
my ($self) = @_;
unless ($self->{_rw} || $self->{_eof} || !$self->{fh}) {
Scalar::Util::weaken $self;
$self->{_rw} = AE::io $self->{fh}, 0, sub {
my ($read) = sort grep {defined} $global_read_size,
$self->{read_size};
my ($period) = sort grep {defined} $global_period,
$self->{_period};
lib/AnyEvent/Handle/Throttle.pm view on Meta::CPAN
}
sub _drain_wbuf {
my ($self) = @_;
if (!$self->{_ww} && $self->{wbuf} && length $self->{wbuf}) {
Scalar::Util::weaken $self;
my $cb;
my $poll = sub {
$self->{_ww} = AE::io $self->{fh}, 1, $cb
if length $self->{wbuf};
};
view release on metacpan or search on metacpan
lib/AnyEvent/Handle/UDP.pm view on Meta::CPAN
my $time = $self->{$on_timeout};
my $error = do { local $! = Errno::ETIMEDOUT; "$!" };
$time ? $time->($self) : $self->_error(0, $error);
return if not exists $self->{$timeout};
}
Scalar::Util::weaken($self);
return if not $self;
$self->{$timer} = AE::timer($after, 0, sub {
delete $self->{$timer};
$callback->($self);
});
view release on metacpan or search on metacpan
lib/AnyEvent/Handle/ZeroMQ.pm view on Meta::CPAN
use strict;
use warnings;
use AE;
use ZeroMQ qw(:all);
use Scalar::Util qw(weaken);
use base qw(Exporter);
our %EXPORT_TAGS = ( constant => [qw(SOCKET RQUEUE WQUEUE RWATCHER WWATCHER ON_DRAIN DEALER ROUTER)] );
our @EXPORT_OK = map { @$_ } values %EXPORT_TAGS;
lib/AnyEvent/Handle/ZeroMQ.pm view on Meta::CPAN
[],
AE::io($fd, 0, sub { _consume_read_write($wself) }),
undef,
], $class;
weaken $wself;
if( exists $args{on_drain} ) {
on_drain($self, $args{on_drain});
}
if( exists $args{on_error} ) {
view release on metacpan or search on metacpan
lib/AnyEvent/IRC/Client.pm view on Meta::CPAN
package AnyEvent::IRC::Client;
use common::sense;
use Scalar::Util qw/weaken/;
use Encode;
use AnyEvent::Socket;
use AnyEvent::Handle;
use AnyEvent::IRC::Util
lib/AnyEvent/IRC/Client.pm view on Meta::CPAN
$type = lc $type;
my $id = ++$self->{dcc_id};
my $dcc = $self->{dcc}->{$id} = { id => $id, type => $type, dest => $dest };
weaken $dcc;
weaken $self;
$dcc->{timeout} = AnyEvent->timer (after => $timeout || 5 * 60, cb => sub {
$self->dcc_disconnect ($id, "TIMEOUT") if $self;
});
lib/AnyEvent/IRC/Client.pm view on Meta::CPAN
my ($self, $id, $timeout) = @_;
my $dcc = $self->{dcc}->{$id}
or return;
weaken $dcc;
weaken $self;
$dcc->{timeout} = AnyEvent->timer (after => $timeout || 5 * 60, cb => sub {
$self->dcc_disconnect ($id, "CONNECT TIMEOUT") if $self;
});
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
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/Lingr.pm view on Meta::CPAN
$self->_on_error($res, $hdr);
}
});
}
Scalar::Util::weaken($self);
}
sub update_room_info {
my ($self) = @_;
$self->_get_channels;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
sub _update_room_info {
my ($self, $rooms) = @_;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
sub _start_observe {
my ($self, $rooms) = @_;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
sub _polling {
my ($self) = @_;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
};
Scalar::Util::weaken($self);
$self->_polling_guard( $guard );
}
sub say {
lib/AnyEvent/Lingr.pm view on Meta::CPAN
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
1;
__END__
view release on metacpan or search on metacpan
MP/Kernel.pm view on Meta::CPAN
_unmonitor undef, $portid, delete $NODE{$SRCNODE}{rmon}{$portid}
if exists $NODE{$SRCNODE};
},
mon1 => sub { # start monitoring a port for another node
my $portid = shift;
Scalar::Util::weaken (my $node = $NODE{$SRCNODE});
_monitor undef, $portid, $node->{rmon}{$portid} = sub {
delete $node->{rmon}{$portid};
$node->send (["", kil0 => $portid, @_])
if $node && $node->{transport};
};
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;