view release on metacpan or search on metacpan
perllib/Arch/Run.pm view on Meta::CPAN
=item B<mode> => I<$accum_mode>
Control how output data is accumulated and passed to B<data> and
B<finish> callbacks.
I<$accum_mode> can be one of
=over 4
perllib/Arch/Run.pm view on Meta::CPAN
read. It will block otherwise.
=item B<poll> I<$timeout>
Check running subprocesses for available output and run callbacks as
appropriate. Wait at most I<$timeout> seconds when no output is
available.
Returns the number of processes that had output available.
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP
view release on metacpan or search on metacpan
lib/Archive/ByteBoozer.pm view on Meta::CPAN
sub crunch {
my $params = { @_ };
validate(
@_, {
source => { type => HANDLE, isa => 'IO::Handle', callbacks => {
is_not_the_same_as_target => sub { exists $_[1]->{target} && refaddr $_[0] != refaddr $_[1]->{target} },
} },
target => { type => HANDLE, isa => 'IO::Handle', callbacks => {
is_not_the_same_as_source => sub { exists $_[1]->{source} && refaddr $_[0] != refaddr $_[1]->{source} },
} },
attach_decruncher => { type => SCALAR, optional => 1, callbacks => {
is_valid_memory_address => sub { looks_like_number $_[0] && $_[0] >= 0x0000 && $_[0] <= 0xffff },
} },
make_executable => { type => SCALAR, optional => 1, callbacks => {
is_valid_memory_address => sub { looks_like_number $_[0] && $_[0] >= 0x0000 && $_[0] <= 0xffff },
} },
precede_initial_address => { type => SCALAR, optional => 1, callbacks => {
is_valid_memory_address => sub { looks_like_number $_[0] && $_[0] >= 0x0000 && $_[0] <= 0xffff },
} },
relocate_output => { type => SCALAR, optional => 1, callbacks => {
is_valid_memory_address => sub { looks_like_number $_[0] && $_[0] >= 0x0000 && $_[0] <= 0xffff },
} },
relocate_output_up_to => { type => SCALAR, optional => 1, callbacks => {
is_valid_memory_address => sub { looks_like_number $_[0] && $_[0] >= 0x0000 && $_[0] <= 0xffff },
} },
replace_initial_address => { type => SCALAR, optional => 1, callbacks => {
is_valid_memory_address => sub { looks_like_number $_[0] && $_[0] >= 0x0000 && $_[0] <= 0xffff },
} },
verbose => { type => SCALAR, optional => 1, regex => qr/^\d+$/ },
}
);
view release on metacpan or search on metacpan
lib/Archive/Lha/Decode.pm view on Meta::CPAN
=head1 DESCRIPTION
This is used to decode/extract an archived file from the stream. Actually this ::Decode class is a factory and decoding is done by a delegated class according to the header's "method" property.
All of the ::Decode subclasses require read/write callbacks. Read callback should take a byte length as an argument, and return the bytes of the length from a file or a string. Write callback should take a part of the decoded (probably binary) string...
=head1 METHODS
=head2 new
takes an Archive::Lha::Header object, and read/write callbacks and creates an appropriate object.
=head2 decode
does the decoding stuff and returns CRC-16 of the decoded string. The decoded string itself is passed to the write callback while decoding (step by step).
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP
view release on metacpan or search on metacpan
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
use strict;
use warnings;
use 5.008;
# ABSTRACT: Libarchive callbacks
our $VERSION = '0.0902'; # VERSION
package
Archive::Libarchive::FFI;
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
CB_SEEK => 6,
CB_SWITCH => 7,
CB_BUFFER => 8,
};
my %callbacks;
do {
no warnings 'redefine';
sub _attach_function ($$$;$)
{
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
};
my $myopen = FFI::Raw::Callback->new(sub {
my($archive) = @_;
my $status = eval {
$callbacks{$archive}->[CB_OPEN]->($archive, $callbacks{$archive}->[CB_DATA]);
};
if($@)
{
warn $@;
return ARCHIVE_FATAL();
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
my $mywrite = FFI::Raw::Callback->new(sub
{
my($archive, $null, $ptr, $size) = @_;
my $buffer = buffer_to_scalar($ptr, $size);
my $status = eval {
$callbacks{$archive}->[CB_WRITE]->($archive, $callbacks{$archive}->[CB_DATA], $buffer);
};
if($@)
{
warn $@;
return ARCHIVE_FATAL();
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
my $myread = FFI::Raw::Callback->new(sub
{
my($archive, $null, $optr) = @_;
my($status, $buffer) = eval {
$callbacks{$archive}->[CB_READ]->($archive, $callbacks{$archive}->[CB_DATA]);
};
if($@)
{
warn $@;
return ARCHIVE_FATAL();
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
my $myskip = FFI::Raw::Callback->new(sub
{
my($archive, $null, $request) = @_;
my $status = eval {
$callbacks{$archive}->[CB_SKIP]->($archive, $callbacks{$archive}->[CB_DATA], $request);
};
if($@)
{
warn $@;
return ARCHIVE_FATAL();
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
my $myseek = FFI::Raw::Callback->new(sub
{
my($archive, $null, $offset, $whence) = @_;
my $status = eval {
$callbacks{$archive}->[CB_SEEK]->($archive, $callbacks{$archive}->[CB_DATA], $offset, $whence);
};
if($@)
{
warn $@;
return ARCHIVE_FATAL();
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
my $myclose = FFI::Raw::Callback->new(sub
{
my($archive) = @_;
my $status = eval {
$callbacks{$archive}->[CB_CLOSE]->($archive, $callbacks{$archive}->[CB_DATA]);
};
if($@)
{
warn $@;
return ARCHIVE_FATAL();
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
}, _int, _ptr, _ptr);
_attach_function 'archive_write_open', [ _ptr, _ptr, _ptr, _ptr, _ptr ], _int, sub
{
my($cb, $archive, $cd, $open, $write, $close) = @_;
$callbacks{$archive}->[CB_DATA] = $cd;
if(defined $open)
{
$callbacks{$archive}->[CB_OPEN] = $open;
$open = $myopen;
}
if(defined $write)
{
$callbacks{$archive}->[CB_WRITE] = $write;
$write = $mywrite;
}
if(defined $close)
{
$callbacks{$archive}->[CB_CLOSE] = $close;
$close = $myclose;
}
$cb->($archive, undef, $open||0, $write||0, $close||0);
};
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
}
_attach_function 'archive_read_open2', [ _ptr, _ptr, _ptr, _ptr, _ptr, _ptr ], _int, sub
{
my($cb, $archive, $cd, $open, $read, $skip, $close) = @_;
$callbacks{$archive}->[CB_DATA] = $cd;
if(defined $open)
{
$callbacks{$archive}->[CB_OPEN] = $open;
$open = $myopen;
}
if(defined $read)
{
$callbacks{$archive}->[CB_READ] = $read;
$read = $myread;
}
if(defined $skip)
{
$callbacks{$archive}->[CB_SKIP] = $skip;
$skip = $myskip;
}
if(defined $close)
{
$callbacks{$archive}->[CB_CLOSE] = $close;
$close = $myclose;
}
$cb->($archive, undef, $open||0, $read||0, $skip||0, $close||0);
};
sub archive_read_set_callback_data ($$)
{
my($archive, $data) = @_;
$callbacks{$archive}->[CB_DATA] = $data;
ARCHIVE_OK();
}
foreach my $name (qw( open read skip close seek ))
{
my $const = 'CB_' . uc $name;
my $wrapper = eval '# line '. __LINE__ . ' "' . __FILE__ . "\n" . qq{
sub
{
my(\$cb, \$archive, \$callback) = \@_;
\$callbacks{\$archive}->[$const] = \$callback;
\$cb->(\$archive, \$my$name);
}
};die $@ if $@;
_attach_function "archive_read_set_$name\_callback", [ _ptr, _ptr ], _int;
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
_attach_function 'archive_read_open_memory', [ _ptr, _ptr, _size_t ], _int, sub
{
my($cb, $archive, $buffer) = @_;
my $length = do { use bytes; length $buffer };
my $ptr = FFI::Raw::MemPtr->new_from_buf($buffer, $length);
$callbacks{$archive}->[CB_BUFFER] = $ptr; # TODO: CB_BUFFER or CB_DATA (or something else?)
$cb->($archive, $ptr, $length);
};
}
else
{
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
_attach_function archive_version_number() >= 3000000 ? 'archive_read_free' : [ archive_read_finish => 'archive_read_free' ], [ _ptr ], _int, sub
{
my($cb, $archive) = @_;
my $ret = $cb->($archive);
delete $callbacks{$archive};
$ret;
};
_attach_function archive_version_number() >= 3000000 ? 'archive_write_free' : [ archive_write_finish => 'archive_write_free' ], [ _ptr ], _int, sub
{
my($cb, $archive) = @_;
my $ret = $cb->($archive);
delete $callbacks{$archive};
$ret;
};
my %lookups;
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
=encoding UTF-8
=head1 NAME
Archive::Libarchive::FFI::Callback - Libarchive callbacks
=head1 VERSION
version 0.0902
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
=head1 DESCRIPTION
This document provides information of callback routines for writing
custom input/output interfaces to the libarchive perl bindings. The
first two arguments passed into all callbacks are:
=over 4
=item $archive
lib/Archive/Libarchive/FFI/Callback.pm view on Meta::CPAN
=back
For the variable name / types conventions used in this document, see
L<Archive::Libarchive::FFI::Function>.
The expected return value for all callbacks EXCEPT the read callback
is a standard integer libarchive status value (example: C<ARCHIVE_OK>
or C<ARCHIVE_FATAL>).
If your callback dies (throws an exception), it will be caught at the
Perl level. The error will be sent to standard error via L<warn|perlfunc#warn>
and C<ARCHIVE_FATAL> will be passed back to libarchive.
=head2 data
There is a data field for callbacks associated with each $archive object.
It can be any native Perl type (example: scalar, hashref, coderef, etc).
You can set this by calling
L<archive_read_set_callback_data|Archive::Libarchive::FFI::Function#archive_read_set_callback_data>,
or by passing the data argument when you "open" the archive using
L<archive_read_open|Archive::Libarchive::FFI::Function#archive_read_open>,
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP
view release on metacpan or search on metacpan
lib/Archive/Libarchive/XS/Callback.pm view on Meta::CPAN
CB_SKIP => 5,
CB_SEEK => 6,
CB_BUFFER => 7,
};
my %callbacks;
sub ARCHIVE_FATAL ();
sub ARCHIVE_OK ();
sub archive_read_set_callback_data ($$)
{
my($archive, $data) = @_;
$callbacks{$archive}->[CB_DATA] = $data;
ARCHIVE_OK;
}
foreach my $name (qw( open read skip close seek ))
{
my $const = 'CB_' . uc $name;
eval '# line '. __LINE__ . ' "' . __FILE__ . "\n" . qq{
sub archive_read_set_$name\_callback (\$\$)
{
my(\$archive, \$callback) = \@_;
\$callbacks{\$archive}->[$const] = \$callback;
_archive_read_set_$name\_callback(\$archive, \$callback);
}
}; die $@ if $@;
}
lib/Archive/Libarchive/XS/Callback.pm view on Meta::CPAN
my $uc_name = uc $name;
eval '# line '. __LINE__ . ' "' . __FILE__ . "\n" . qq{
sub _my$name
{
my \$archive = shift;
my \$status = eval { \$callbacks{\$archive}->[CB_$uc_name]->(\$archive, \$callbacks{\$archive}->[CB_DATA],\@_) };
if(\$\@)
{
warn \$\@;
return ARCHIVE_FATAL;
}
lib/Archive/Libarchive/XS/Callback.pm view on Meta::CPAN
sub _myread
{
my($archive) = @_;
my ($status, $buffer) = eval {
$callbacks{$archive}->[CB_READ]->(
$archive,
$callbacks{$archive}->[CB_DATA],
)
};
if($@)
{
warn $@;
return (ARCHIVE_FATAL, undef);
}
$callbacks{$archive}->[CB_BUFFER] = \$buffer;
($status, $callbacks{$archive}->[CB_BUFFER]);
}
sub _mywrite
{
my($archive, $buffer) = @_;
my $status = eval {
$callbacks{$archive}->[CB_WRITE]->(
$archive,
$callbacks{$archive}->[CB_DATA],
$buffer,
)
};
if($@)
{
lib/Archive/Libarchive/XS/Callback.pm view on Meta::CPAN
}
sub archive_read_open ($$$$$)
{
my($archive, $data, $opencb, $readcb, $closecb) = @_;
$callbacks{$archive}->[CB_DATA] = $data if defined $data;
$callbacks{$archive}->[CB_OPEN] = $opencb if defined $opencb;
$callbacks{$archive}->[CB_READ] = $readcb if defined $readcb;
$callbacks{$archive}->[CB_CLOSE] = $closecb if defined $closecb;
my $ret = _archive_read_open($archive, $data, $opencb, $readcb, $closecb);
$ret;
}
sub archive_read_open2 ($$$$$$)
{
my($archive, $data, $opencb, $readcb, $skipcb, $closecb) = @_;
$callbacks{$archive}->[CB_DATA] = $data if defined $data;
$callbacks{$archive}->[CB_OPEN] = $opencb if defined $opencb;
$callbacks{$archive}->[CB_READ] = $readcb if defined $readcb;
$callbacks{$archive}->[CB_SKIP] = $skipcb if defined $skipcb;
$callbacks{$archive}->[CB_CLOSE] = $closecb if defined $closecb;
my $ret = _archive_read_open2($archive, $data, $opencb, $readcb, $skipcb, $closecb);
$ret;
}
sub archive_write_open ($$$$$)
{
my($archive, $data, $opencb, $writecb, $closecb) = @_;
$callbacks{$archive}->[CB_DATA] = $data if defined $data;
$callbacks{$archive}->[CB_OPEN] = $opencb if defined $opencb;
$callbacks{$archive}->[CB_WRITE] = $writecb if defined $writecb;
$callbacks{$archive}->[CB_CLOSE] = $closecb if defined $closecb;
my $ret = _archive_write_open($archive, $data, $opencb, $writecb, $closecb);
$ret;
}
sub archive_read_free ($)
{
my($archive) = @_;
my $ret = _archive_read_free($archive);
delete $callbacks{$archive};
$ret;
}
sub archive_write_free ($)
{
my($archive) = @_;
my $ret = _archive_write_free($archive);
delete $callbacks{$archive};
$ret;
}
sub archive_set_error
{
lib/Archive/Libarchive/XS/Callback.pm view on Meta::CPAN
=head1 DESCRIPTION
This document provides information of callback routines for writing
custom input/output interfaces to the libarchive perl bindings. The
first two arguments passed into all callbacks are:
=over 4
=item $archive
lib/Archive/Libarchive/XS/Callback.pm view on Meta::CPAN
=back
For the variable name / types conventions used in this document, see
L<Archive::Libarchive::XS::Function>.
The expected return value for all callbacks EXCEPT the read callback
is a standard integer libarchive status value (example: C<ARCHIVE_OK>
or C<ARCHIVE_FATAL>).
If your callback dies (throws an exception), it will be caught at the
Perl level. The error will be sent to standard error via L<warn|perlfunc#warn>
and C<ARCHIVE_FATAL> will be passed back to libarchive.
=head2 data
There is a data field for callbacks associated with each $archive object.
It can be any native Perl type (example: scalar, hashref, coderef, etc).
You can set this by calling
L<archive_read_set_callback_data|Archive::Libarchive::XS::Function#archive_read_set_callback_data>,
or by passing the data argument when you "open" the archive using
L<archive_read_open|Archive::Libarchive::XS::Function#archive_read_open>,
view release on metacpan or search on metacpan
lib/Archive/Libarchive.pm view on Meta::CPAN
Support calls allow L<Archive::Libarchive> to decide when to use a feature; "set" calls
enable the feature unconditionally.
=item "Open" a particular data source
This can be using callbacks for a custom source, or one of the pre-canned data sources supported directly by
L<Archive::Libarchive>.
=item Iterate over the contents
Ask alternatively for "header" or entry/file metadata (which is represented by a L<Archive::Libarchive::Entry> instance),
lib/Archive/Libarchive.pm view on Meta::CPAN
file handle.
=head2 List contents of archive with custom read functions
Sometimes, none of the packaged open methods will work for you. In that case, you can use the lower-level C<open>
method, which accepts a number of callbacks. For this example we will use the C<open>, C<read> and C<close>
callbacks.
use 5.020;
use Archive::Libarchive qw( :const );
my $r = Archive::Libarchive::ArchiveRead->new;
lib/Archive/Libarchive.pm view on Meta::CPAN
say $e->pathname;
}
$r->close;
For full power of read callbacks see the L<open method's documentation|Archive::Libarchive::ArchiveRead/open>.
When writing to an archive the L<Archive::Libarchive::ArchiveWrite> class also has its own
L<open method and callbacks|Archive::Libarchive::ArchiveWrite/open>.
=head2 A universal decompressor / defilter-er
The "raw" format handler treats arbitrary binary input as a single-element archive. This allows you to get the
output of a libarchive filter chain, including files with multiple encodings, such as C<gz.uu> files:
view release on metacpan or search on metacpan
lib/Archive/TAP/Convert.pm view on Meta::CPAN
$formatter->prepare;
my $session;
my $aggregator = TAP::Harness::Archive->aggregator_from_archive({
archive => $args{archive},
parser_callbacks => {
ALL => sub {
$session->result( $_[0] );
},
},
made_parser_callback => sub {
view release on metacpan or search on metacpan
unzip-6.0/amiga/filedate.c view on Meta::CPAN
#include "crypt.h" /* just so we can tell if CRYPT is supported */
#if (!defined(FUNZIP) && !defined(UTIL))
#include "timezone.h" /* for AMIGA-specific timezone callbacks */
#ifndef SUCCESS
# define SUCCESS (-1L)
# define FAILURE 0L
#endif
view release on metacpan or search on metacpan
lib/Argon/Client.pm view on Meta::CPAN
sub BUILD {
my ($self, $args) = @_;
if ($self->channel) {
# Set callbacks
$self->channel->on_msg(K('_notify', $self));
$self->channel->on_err(K('_error', $self));
$self->channel->on_close(K('_close', $self));
if ($self->channel->is_ready) {
view release on metacpan or search on metacpan
lib/Array/IntSpan/Fields.pm view on Meta::CPAN
sub adapt_range_in_cb
{
my $self = shift;
# the callbacks will be called with ($start, $end,$payload) or
# ($start,$end)
my @callbacks = @_ ;
return map
{
my $old_cb = $_; # required for closure to work
defined $old_cb ?
lib/Array/IntSpan/Fields.pm view on Meta::CPAN
my ($s_int,$e_int,$value) = @_ ;
my ($s,$e) = $self->int_to_field($s_int,$e_int) ;
$old_cb->($s,$e,$value);
}
: undef ;
} @callbacks ;
}
sub get_element
{
my ($self,$idx) = @_;
view release on metacpan or search on metacpan
lib/Array/Join/OO.pm view on Meta::CPAN
=head1 DESCRIPTION
C<Array::Join::OO> performs SQL-style joins over two Perl arrays.
Each array element is typically a hashref. Join keys are produced
by user-supplied callbacks.
The module supports C<inner>, C<left>, C<right>, and C<outer> joins
and multiple merge strategies for combining matching rows.
Multiple rows per key are supported; all matching combinations
lib/Array/Join/OO.pm view on Meta::CPAN
=over 4
=item * on => [ sub {...}, sub {...} ]
Required. Two callbacks that extract a join key from items in
the left and right arrays respectively.
=item * type => 'inner' | 'left' | 'right' | 'outer'
Join type. Defaults to C<inner>.
view release on metacpan or search on metacpan
lib/ArrayData/Lingua/Word/EN/Enable.pm view on Meta::CPAN
callans
callant
callants
callas
callback
callbacks
callboy
callboys
called
caller
callers
view release on metacpan or search on metacpan
lib/ArrayData/Word/EN/Enable.pm view on Meta::CPAN
callans
callant
callants
callas
callback
callbacks
callboy
callboys
called
caller
callers
view release on metacpan or search on metacpan
lib/Ask/Callback.pm view on Meta::CPAN
__END__
=head1 NAME
Ask::Callback - interact with yourself via callbacks
=head1 SYNOPSIS
my $ask = Ask::Callback->new(
input_callback => sub { ... },
view release on metacpan or search on metacpan
lib/Aspect.pm view on Meta::CPAN
* We need a way to match subs with an attribute, attributes::get()
will currently not work.
* isa() support for method pointcuts as Gaal Yahas suggested: match
methods on class hierarchies without callbacks
* Perl join points: phasic- BEGIN/INIT/CHECK/END
=head2 Weaving
view release on metacpan or search on metacpan
lib/Assert/Refute.pm view on Meta::CPAN
More arguments MAY be added in the future.
Return value is ignored.
A read-only report instance is returned by C<try_refute> instead.
If C<on_pass>/C<on_fail> callbacks were specified during C<use> or
using C<configure>, they will also be executed if appropriate.
If C<NDEBUG> or C<PERL_NDEBUG> environment variable is set at compile time,
this block is replaced with a stub
which returns an unconditionally passing report.
lib/Assert/Refute.pm view on Meta::CPAN
More arguments MAY be added in the future.
Return value is ignored.
A read-only report instance is returned by C<try_refute> instead.
If C<on_pass>/C<on_fail> callbacks were specified during C<use> or
using C<configure>, they will also be executed if appropriate.
If C<NDEBUG> or C<PERL_NDEBUG> environment variable is set at compile time,
this block is replaced with a stub
which returns an unconditionally passing report.
lib/Assert/Refute.pm view on Meta::CPAN
is $price * $amount, $total, "Numbers add up";
like $header, qr/<h1>/, "Header as expected";
can_ok $duck, "quack";
};
This method does not adhere C<NDEBUG>, apply callbacks, or handle expections.
It just executes the checks.
Not exported by default.
B<[EXPERIMENTAL]>. Name and behavior MAY change in the future.
Should this function prove useful, it will become the successor
lib/Assert/Refute.pm view on Meta::CPAN
B<[EXPERIMENTAL]>. Name and meaning MAY change in the future.
=back
The callbacks MUST be either
a C<CODEREF> accepting L<Assert::Refute::Report> object,
or one of predefined strings:
=over
view release on metacpan or search on metacpan
lib/Asterisk/AMI.pm view on Meta::CPAN
If you are running an event loop and use blocking methods (e.g. get_response, check_response, action,
simple_action, connected, or a blocking connect) the outcome is unspecified. It may work, it may lock everything up, the action may
work but break something else. I have tested it and behavior seems unpredictable at best and is very
circumstantial.
If you are running an event-loop use non-blocking callbacks! It is why they are there!
However if you do play with blocking methods inside of your loops let me know how it goes.
=head2 Actions
lib/Asterisk/AMI.pm view on Meta::CPAN
});
=head3 Originate Examples
These don't include non-blocking examples, please read the section on 'Callbacks' below for information
on using non-blocking callbacks and events.
NOTE: Please read about the 'OriginateHack' option for the constructor above if you plan on using the 'Async'
option in your Originate command, as it may be required to properly retrieve the response.
In these examples we are dialing extension '12345' at a sip peer named 'peer' and when the call connects
lib/Asterisk/AMI.pm view on Meta::CPAN
=head3 Callback Caveats
Callbacks only work if we are processing packets, therefore you must be running an event loop. Alternatively, we run
mini-event loops for our blocking calls (e.g. action(), get_action()), so in theory if you set callbacks and then
issue a blocking call those callbacks should also get triggered. However this is an unsupported scenario.
Timeouts are done using timers and they are set as soon as you send the object. Therefore if you send an action with a
timeout and then monkey around for a long time before getting back to your event loop (to process input) you can time
out before ever even attempting to receive the response.
lib/Asterisk/AMI.pm view on Meta::CPAN
Returns 1 if there are currently errors on the socket, 0 if everything is ok.
destroy ()
Destroys the contents of all buffers and removes any current callbacks that are set.
Mostly used internally. Useful if you want to ensure that our IO handle watcher gets removed.
Gets called automatically when our object goes out of scope.
loop ()
lib/Asterisk/AMI.pm view on Meta::CPAN
my ($self, $message) = @_;
warnings::warnif('Asterisk::AMI', "Failed to connect to asterisk - $self->{CONFIG}->{PEERADDR}:$self->{CONFIG}->{PEERPORT}");
warnings::warnif('Asterisk::AMI', "Error Message: $message");
#Dispatch all callbacks as if they timed out
$self->_clear_cbs();
if (exists $self->{CONFIG}->{ON_CONNECT_ERR}) {
$self->{CONFIG}->{ON_CONNECT_ERR}->($self, $message);
} elsif (exists $self->{CONFIG}->{ON_ERROR}) {
lib/Asterisk/AMI.pm view on Meta::CPAN
my ($self) = @_;
my $message = "Remote end disconnected - $self->{CONFIG}->{PEERADDR}:$self->{CONFIG}->{PEERPORT}";
warnings::warnif('Asterisk::AMI', "Remote Asterisk Server ended connection - $self->{CONFIG}->{PEERADDR}:$self->{CONFIG}->{PEERPORT}");
#Call all callbacks as if they had timed out
_
$self->_clear_cbs();
if (exists $self->{CONFIG}->{ON_DISCONNECT}) {
$self->{CONFIG}->{ON_DISCONNECT}->($self, $message);
lib/Asterisk/AMI.pm view on Meta::CPAN
return 1;
}
#Used once and action completes
#Determines goodness and performs any oustanding callbacks
sub _action_complete {
my ($self, $actionid) = @_;
#Determine 'Goodness'
if (defined $self->{RESPONSEBUFFER}->{$actionid}->{'Response'}
lib/Asterisk/AMI.pm view on Meta::CPAN
}
return 1;
}
#Handles proccessing and callbacks for action responses
sub _handle_action {
my ($self, $packet) = @_;
#Snag our actionid
my $actionid = $packet->{'ActionID'};
lib/Asterisk/AMI.pm view on Meta::CPAN
}
return 1;
}
#Handles proccessing and callbacks for 'Event' packets
sub _handle_event {
my ($self, $event) = @_;
#If handlers were configured just dispatch, don't buffer
if ($self->{CONFIG}->{HANDLERS}) {
lib/Asterisk/AMI.pm view on Meta::CPAN
}
return 1;
}
#This is used to provide blocking behavior for calls It installs callbacks for an action if it is not in the buffer
#and waits for the response before returning it.
sub _wait_response {
my ($self, $id, $timeout) = @_;
#Already got it?
lib/Asterisk/AMI.pm view on Meta::CPAN
#Callback for login action
my $login_cb = sub { $self->_logged_in($_[1]) };
#Do a md5 challenge
if (%{$challenge}) {
#Create callbacks for the challenge
my $challenge_cb = sub {
if ($_[1]->{'GOOD'}) {
my $md5 = Digest::MD5->new();
$md5->add($_[1]->{'PARSED'}->{'Challenge'});
lib/Asterisk/AMI.pm view on Meta::CPAN
my $timeout = $self->{CONFIG}->{TIMEOUT} || 5;
return $self->send_action({ Action => 'Ping' }, $cb, $timeout);
}
#Calls all callbacks as if they had timed out Used when an error has occured on the socket
sub _clear_cbs {
my ($self) = @_;
foreach my $id (keys %{$self->{CALLBACKS}}) {
my $response = $self->{RESPONSEBUFFER}->{$id};
view release on metacpan or search on metacpan
lib/Asterisk/CoroManager.pm view on Meta::CPAN
port => $args->{port} || 5038,
user => $args->{user},
secret => $args->{secret},
watcher => undef,
finished => undef, # Will hold AnyEvent->condvar
action_cb => {}, # Action response callbacks
event_cb => {}, # event callbacks
event_dcb => undef, # event default callback
uevent_cb => {}, # userevent callbacks
uevent_dcb => undef, # userevent default callback
ami_version => undef,
read_buffer => [],
}, __PACKAGE__;
lib/Asterisk/CoroManager.pm view on Meta::CPAN
sub handle_event {
my( $astman, $pack ) = @_;
my $event = $pack->{Event};
if ( my $callbacks =
$astman->{event_cb}{$event} ||
$astman->{event_dcb}
) {
$astman->debug("Handling event: $event");
foreach my $cb (@$callbacks) {
&{$cb}($pack);
}
}
else {
$astman->trace("Unhandled event: $event");
lib/Asterisk/CoroManager.pm view on Meta::CPAN
sub handle_uevent {
my( $astman, $pack ) = @_;
my $uevent = $pack->{UserEvent};
if ( my $callbacks =
$astman->{uevent_cb}{$uevent} ||
$astman->{uevent_dcb} ||
$astman->{event_dcb}
) {
$astman->debug("Handling uevent: $uevent");
foreach my $cb (@$callbacks) {
&{$cb}($pack);
}
}
else {
$astman->trace("Unhandled uevent: $uevent");
view release on metacpan or search on metacpan
lib/Astro/FITS/CFITSIO/Simple.pm view on Meta::CPAN
depends => 'extname',
default => 0
},
hdunum => {
type => SCALAR,
callbacks => { 'illegal HDUNUM' => \&validHDUNUM, },
optional => 1
},
hdutype => {
type => SCALAR,
callbacks => { 'illegal HDU type' => \&validHDUTYPE, },
default => 'any',
optional => 1
},
resethdu => { type => SCALAR, default => 0 },
);
view release on metacpan or search on metacpan
lib/Astro/Montenbruck/RiseSet.pm view on Meta::CPAN
}
);
return %res;
}
# if caller doesn't ask for a result, just call the function with the callbacks
$func->(
get_position => sub { _get_equatorial( $pla, $_[0] ) },
sin_h0 => sin( deg2rad($h0) ),
on_event => $arg{on_event},
on_noevent => $arg{on_noevent},
lib/Astro/Montenbruck/RiseSet.pm view on Meta::CPAN
}
}
return %res;
}
# if caller doesn't ask for a result, just call the function with the callbacks
for (@RS_EVENTS) {
my ( $state, $jd ) = $evt_func->($_);
if ( $state eq $_ ) {
$arg{on_event}->( $_, $jd );
}
lib/Astro/Montenbruck/RiseSet.pm view on Meta::CPAN
=head3 Returns
function, which calculates rise, set and transit for a celestial body.
It accepts celestial body identifier as positional argument (see L<Astro::Montenbruck::Ephemeris::Planet>)
and two optional callbacks as named arguments:
=over
=item *
lib/Astro/Montenbruck/RiseSet.pm view on Meta::CPAN
=back
=head3 Returns
function, which calculates rise and set times of the planet. It accepts and two callbacks as named arguments:
=over
=item *
view release on metacpan or search on metacpan
lib/Astro/XSPEC/Model/Parse.pm view on Meta::CPAN
my $class = shift;
my %par = validate( @_,
{
model => { type => HASHREF,
callbacks => { 'handler' =>
sub {
pop @_;
validate( @_, \%model_handler )
}
},
view release on metacpan or search on metacpan
lib/Async/Chain.pm view on Meta::CPAN
log(...);
};
=head1 RATIONALE
A asynchronous code often have deep nested callbacks, therefore it is tangled
and hard to change. This module help to converta a code like following to some
more readable form. Also, with C<chain> you can easily skip some unneeded steps
in this thread. For example jump to log step after the first failed query in
the chain.
view release on metacpan or search on metacpan
lib/Async/ContextSwitcher.pm view on Meta::CPAN
=item * you create a L</new> context for an entry point
It can be a new web request, a new message from a queue to process
or command line script command
=item * use L</cb_w_context> to create all callbacks in your application
=item * correct context restored when your callbacks are called
=item * use L</context> to access data
=back
lib/Async/ContextSwitcher.pm view on Meta::CPAN
return $CTX = __PACKAGE__->new;
}
=head2 cb_w_context
Wrapper for callbacks. Function is exported. Wraps a callback with code
that stores and restores context to make sure correct context travels
with your code.
async_call( callback => cb_w_context { context->{good} = shift } );
Make sure that all callbacks in your code are created with this function
or you can loose track of your context.
=cut
sub cb_w_context(&) {
view release on metacpan or search on metacpan
lib/Async/Event/Interval.pm view on Meta::CPAN
}
=head2 Shared scalar
L<shared_scalar()|/shared_scalar> returns a tied scalar reference whose value
lives in shared memory and is visible to the parent and to event callbacks.
The sub-sections below show common usage patterns; see
L<shared_scalar()|/shared_scalar> for the API reference and constraints.
=head3 Storing simple types