Result:
found more than 394 distributions - search limited to the first 2001 files matching your query
( run in 1.923 )
AnyEvent-Pg
view release on metacpan or search on metacpan
lib/AnyEvent/Pg.pm view on Meta::CPAN
*** ***
*******************************************************************
This library allows to query PostgreSQL databases asynchronously. It
is a thin layer on top of L<Pg::PQ> that integrates it inside the
L<AnyEvent> framework.
=head2 API
The following methods are available from the AnyEvent::Pg class:
AnyEvent-Process
view release on metacpan or search on metacpan
lib/AnyEvent/Process.pm view on Meta::CPAN
Run the close method of the latest created AnyEvent::Process::Job.
=head1 SEE ALSO
L<AnyEvent> - Event framework for PERL.
L<AnyEvent::Subprocess> - Similar module, but with more dependencies and a little
more complicated usage.
=head1 AUTHOR
AnyEvent-RPC
view release on metacpan or search on metacpan
lib/AnyEvent/RPC.pm view on Meta::CPAN
use warnings;
}; # Until cpants will know it make strict
use Carp;
=head1 NAME
AnyEvent::RPC - Abstract framework for Asyncronous RPC clients
=cut
our $VERSION = '0.05';
AnyEvent-RabbitMQ-Fork
view release on metacpan or search on metacpan
lib/AnyEvent/RabbitMQ/Fork.pm view on Meta::CPAN
user => 'guest',
pass => 'guest',
vhost => '/',
timeout => 1,
tls => 0, # Or 1 if you'd like SSL
tune => { heartbeat => 30, channel_max => $whatever, frame_max = $whatever },
on_success => sub {
my $ar = shift;
$ar->open_channel(
on_success => sub {
my $channel = shift;
lib/AnyEvent/RabbitMQ/Fork.pm view on Meta::CPAN
on_failure => $cv,
);
},
on_failure => $cv,
on_close => sub {
my $method_frame = shift->method_frame;
die $method_frame->reply_code, $method_frame->reply_text;
},
);
},
on_failure => $cv,
on_read_failure => sub { die @_ },
on_return => sub {
my $frame = shift;
die "Unable to deliver ", Dumper($frame);
},
on_close => sub {
my $why = shift;
if (ref($why)) {
my $method_frame = $why->method_frame;
die $method_frame->reply_code, ": ", $method_frame->reply_text;
}
else {
die $why;
}
},
lib/AnyEvent/RabbitMQ/Fork.pm view on Meta::CPAN
=item B<heartbeat> Heartbeat interval in seconds. Default: 0 (off)
=item B<channel_max> Maximum channel ID. Default: 65536
=item B<frame_max> Maximum frame size in bytes. Default: 131072
=back
=item B<on_success> Callback when the connection is successfully established.
AnyEvent-RabbitMQ-PubSub
view release on metacpan or search on metacpan
lib/AnyEvent/RabbitMQ/PubSub.pm view on Meta::CPAN
)
}
sub _report_error {
my ($cv, $why) = @_;
if (ref($why) && $why->can('method_frame')) {
my $method_frame = $why->method_frame;
$cv->croak(longmess(
sprintf '%s: %s',
$method_frame->reply_code || 503,
$method_frame->reply_text || 'Something went wrong.',
));
}
else {
$cv->croak(longmess(Dumper($why)));
}
AnyEvent-RabbitMQ-RPC
view release on metacpan or search on metacpan
lib/AnyEvent/RabbitMQ/RPC.pm view on Meta::CPAN
$self->channel->declare_queue(
no_ack => 1,
durable => 0,
exclusive => 1,
on_success => sub {
$args{on_success}->(shift->method_frame->queue);
},
on_failure => $args{on_failure},
);
}
lib/AnyEvent/RabbitMQ/RPC.pm view on Meta::CPAN
# And set up a listen on it
$self->channel->consume(
queue => $args{name},
no_ack => 0,
on_consume => sub {
my $frame = shift;
my $failed;
my $args = $frame->{body}->payload;
if ($self->{unserialize}) {
try {
$args = $self->{unserialize}->($args);
} catch {
$failed = 1;
lib/AnyEvent/RabbitMQ/RPC.pm view on Meta::CPAN
$args{on_failure}->("Call died: $_");
};
return if $failed;
# Send the response, if they asked for it
if (my $reply_to = $frame->{header}->reply_to) {
if ($self->{serialize}) {
try {
$return = $self->{serialize}->($return);
} catch {
$failed = 1;
lib/AnyEvent/RabbitMQ/RPC.pm view on Meta::CPAN
my $REPLIES = shift;
$self->channel->consume(
queue => $REPLIES,
no_ack => 1,
on_consume => sub {
my $frame = shift;
# We got a reply, tear down our reply queue
$self->channel->delete_queue(
queue => $REPLIES,
);
my $return = $frame->{body}->payload;
if ($self->{unserialize}) {
my $failed;
try {
$return = $self->{unserialize}->($return);
} catch {
AnyEvent-RabbitMQ-Simple
view release on metacpan or search on metacpan
example/simplest.pl view on Meta::CPAN
my $rmq = AnyEvent::RabbitMQ::Simple->new(
failure_cb => sub {
my ($event, $details, $why) = @_;
if ( ref $why ) {
my $method_frame = $why->method_frame;
$why = $method_frame->reply_text;
}
$loop->croak("[ERROR] $event($details): $why" );
},
);
example/simplest.pl view on Meta::CPAN
my $consumer_tag;
$channel->consume(
queue => $queue,
on_success => sub {
my $frame = shift;
$consumer_tag = $frame->method_frame->consumer_tag;
print "************* consuming from $queue with $consumer_tag\n";
},
on_consume => sub {
my $res = shift;
my $body = $res->{body}->payload;
AnyEvent-RabbitMQ
view release on metacpan or search on metacpan
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
_queue => AnyEvent::RabbitMQ::LocalQueue->new,
_last_chan_id => 0,
_channels => {},
_login_user => '',
_server_properties => {},
_frame_max => undef,
_body_max => undef,
_channel_max => undef,
}, $class;
}
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
}
$self->{_handle}->push_read(chunk => $length, sub {
my $self = $weak_self or return;
$stack .= $_[1];
my ($frame) = Net::AMQP->parse_raw_frames(\$stack);
$self->{_heartbeat_recv} = time if $self->{_heartbeat_timer};
if ($self->{verbose}) {
warn '[C] <-- [S] ', Dumper($frame),
'-----------', "\n";
}
my $id = $frame->channel;
if (0 == $id) {
if ($frame->type_id == 8) {
# Heartbeat, no action needs taking.
}
else {
return unless $self->_check_close_and_clean($frame, $close_cb,);
$self->{_queue}->push($frame);
}
} else {
my $channel = $self->{_channels}->{$id};
if (defined $channel) {
$channel->push_queue_or_consume($frame, $failure_cb);
} else {
$failure_cb->('Unknown channel id: ' . $frame->channel);
}
}
@_ = ($self, $close_cb, $failure_cb,);
goto &_read_loop;
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
return $self;
}
sub _check_close_and_clean {
my $self = shift;
my ($frame, $close_cb,) = @_;
my $method_frame = $frame->isa('Net::AMQP::Frame::Method') ? $frame->method_frame : undef;
if ($self->{_state} == _ST_CLOSED) {
return $method_frame && $method_frame->isa('Net::AMQP::Protocol::Connection::CloseOk');
}
if ($method_frame && $method_frame->isa('Net::AMQP::Protocol::Connection::Close')) {
delete $self->{_heartbeat_timer};
$self->_push_write(Net::AMQP::Protocol::Connection::CloseOk->new());
$self->_server_closed($close_cb, $frame);
return;
}
return 1;
}
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
my $self = shift;
my ($close_cb, $why,) = @_;
$self->{_state} = _ST_CLOSING;
for my $channel (values %{ $self->{_channels} }) {
$channel->_closed(ref($why) ? $why : $channel->_close_frame($why));
}
$self->{_channels} = {};
$self->{_handle}->push_shutdown;
$self->{_state} = _ST_CLOSED;
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
$self->{_handle}->push_write(Net::AMQP::Protocol->header);
$self->_push_read_and_valid(
'Connection::Start',
sub {
my $frame = shift;
my @mechanisms = split /\s/, $frame->method_frame->mechanisms;
return $args{on_failure}->('AMQPLAIN is not found in mechanisms')
if none {$_ eq 'AMQPLAIN'} @mechanisms;
my @locales = split /\s/, $frame->method_frame->locales;
return $args{on_failure}->('en_US is not found in locales')
if none {$_ eq 'en_US'} @locales;
$self->{_server_properties} = $frame->method_frame->server_properties;
$self->_push_write(
Net::AMQP::Protocol::Connection::StartOk->new(
client_properties => {
platform => 'Perl',
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
weaken(my $weak_self = $self);
$self->_push_read_and_valid(
'Connection::Tune',
sub {
my $self = $weak_self or return;
my $frame = shift;
my %tune;
foreach (qw( channel_max frame_max heartbeat )) {
my $client = $args{tune}{$_} || 0;
my $server = $frame->method_frame->$_ || 0;
# negotiate with the server such that we cannot request a larger
# value set by the server, unless the server said unlimited
$tune{$_} = ($server == 0 or $client == 0)
? ($server > $client ? $server : $client) # max
: ($client > $server ? $server : $client); # min
}
if ($self->{_frame_max} = $tune{frame_max}) {
# calculate how big the body can actually be
$self->{_body_max} = $self->{_frame_max} - Net::AMQP::_HEADER_LEN - Net::AMQP::_FOOTER_LEN;
}
$self->{_channel_max} = $tune{channel_max} || $DEFAULT_CHANNEL_MAX;
$self->_push_write(
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
my ($method, $args, $exp, $cb, $failure_cb, $id,) = @_;
$method = 'Net::AMQP::Protocol::' . $method;
$self->_push_write(
Net::AMQP::Frame::Method->new(
method_frame => $method->new(%$args)
),
$id,
);
return $self->_push_read_and_valid($exp, $cb, $failure_cb, $id,);
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
$failure_cb->('Unknown channel id: ' . $id);
}
return unless $queue; # Can go away in global destruction..
$queue->get(sub {
my $frame = shift;
return $failure_cb->('Received data is not method frame')
if !$frame->isa('Net::AMQP::Frame::Method');
my $method_frame = $frame->method_frame;
for my $exp_elem (@$exp) {
return $cb->($frame)
if $method_frame->isa('Net::AMQP::Protocol::' . $exp_elem);
}
$failure_cb->(
$method_frame->isa('Net::AMQP::Protocol::Channel::Close')
? 'Channel closed'
: 'Expected ' . join(',', @$exp) . ' but got ' . ref($method_frame)
);
});
}
sub _push_write {
my $self = shift;
my ($output, $id,) = @_;
if ($output->isa('Net::AMQP::Protocol::Base')) {
$output = $output->frame_wrap;
}
$output->channel($id || 0);
if ($self->{verbose}) {
warn '[C] --> [S] ', Dumper($output);
}
$self->{_handle}->push_write($output->to_raw_frame())
if $self->{_handle}; # Careful - could have gone (global destruction)
return;
}
sub _set_cbs {
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
pass => 'guest',
vhost => '/',
timeout => 1,
tls => 0, # Or 1 if you'd like SSL
tls_ctx => $anyevent_tls # or a hash of AnyEvent::TLS options.
tune => { heartbeat => 30, channel_max => $whatever, frame_max = $whatever },
nodelay => 1, # Reduces latency by disabling Nagle's algorithm
on_success => sub {
my $ar = shift;
$ar->open_channel(
on_success => sub {
lib/AnyEvent/RabbitMQ.pm view on Meta::CPAN
on_failure => $cv,
);
},
on_failure => $cv,
on_close => sub {
my $method_frame = shift->method_frame;
die $method_frame->reply_code, $method_frame->reply_text;
},
);
},
on_failure => $cv,
on_read_failure => sub { die @_ },
on_return => sub {
my $frame = shift;
die "Unable to deliver ", Dumper($frame);
},
on_close => sub {
my $why = shift;
if (ref($why)) {
my $method_frame = $why->method_frame;
die $method_frame->reply_code, ": ", $method_frame->reply_text;
}
else {
die $why;
}
},
AnyEvent-ReverseHTTP
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
our @EXPORT = ();
our @EXPORT_BASE = qw(field const stub super);
our @EXPORT_OK = (@EXPORT_BASE, qw(id WWW XXX YYY ZZZ));
our %EXPORT_TAGS = (XXX => [qw(WWW XXX YYY ZZZ)]);
my $stack_frame = 0;
my $dump = 'yaml';
my $bases_map = {};
sub WWW; sub XXX; sub YYY; sub ZZZ;
inc/Spiffy.pm view on Meta::CPAN
unless grep /^XXX$/, @EXPORT_BASE;
}
spiffy_filter()
if ($args->{-selfless} or $args->{-Base}) and
not $filtered_files->{(caller($stack_frame))[1]}++;
my $caller_package = $args->{-package} || caller($stack_frame);
push @{"$caller_package\::ISA"}, $self_package
if $args->{-Base} or $args->{-base};
for my $class (@{all_my_bases($self_package)}) {
next unless $class->isa('Spiffy');
inc/Spiffy.pm view on Meta::CPAN
}
package Spiffy;
sub super {
my $method;
my $frame = 1;
while ($method = (caller($frame++))[3]) {
$method =~ s/.*::// and last;
}
my @args = DB::super_args($frame);
@_ = @_ ? ($args[0], @_) : @args;
my $class = ref $_[0] ? ref $_[0] : $_[0];
my $caller_class = caller;
my $seen = 0;
my @super_classes = reverse grep {
inc/Spiffy.pm view on Meta::CPAN
for my $base_class (@base_classes) {
next if $inheritor->isa($base_class);
croak "Can't mix Spiffy and non-Spiffy classes in 'use base'.\n",
"See the documentation of Spiffy.pm for details\n "
unless $base_class->isa('Spiffy');
$stack_frame = 1; # tell import to use different caller
import($base_class, '-base');
$stack_frame = 0;
}
}
sub mixin {
my $self = shift;
AnyEvent-STOMP-Client
view release on metacpan or search on metacpan
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
$self->{connected} = 0;
$self->event('TRANSPORT_DISCONNECTED', $self->{host}, $self->{port});
},
on_connect => sub {
$self->event('TRANSPORT_CONNECTED', $self->{host}, $self->{port});
$self->send_frame('CONNECT', $self->{connect_headers});
},
on_connect_error => sub {
my ($handle, $error_message) = @_;
$handle->destroy;
undef $self->{handle};
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
# https://metacpan.org/pod/AnyEvent::Handle#on_error-=%3E-$cb-%3E($handle,-$fatal,-$message)
$self->event('CONNECTION_LOST', $self->{host}, $self->{port}, $error_message);
}
},
on_read => sub {
$self->read_frame;
},
%{$self->{tls_hash}},
);
}
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
delete $self->{heartbeat}{timer};
return;
}
if (defined $ungraceful and $ungraceful) {
$self->send_frame('DISCONNECT');
$self->{connected} = 0;
if (defined $self->{handle}) {
$self->{handle}->push_shutdown;
$self->{handle}->destroy;
delete $self->{handle};
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
delete $self->{heartbeat}{timer};
}
else {
my $receipt_id = $self->get_uuid;
$self->send_frame('DISCONNECT', {receipt => $receipt_id,});
$self->before_receipt(
sub {
my ($self, $header) = @_;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
}
}
);
}
$self->send_frame('SUBSCRIBE', $header);
}
return $self->{subscriptions}{$destination};
}
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
}
}
);
}
$self->send_frame('UNSUBSCRIBE', $header);
delete $self->{subscriptions}{$destination};
}
sub header_hash2string {
my $header_hashref = shift;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
}
return $result_hashref;
}
sub send_frame {
my ($self, $command, $header_hashref, $body) = @_;
unless ($self->is_connected or $command eq 'CONNECT') {
croak "Have you considered connecting to a STOMP broker first before "
."trying to send something?";
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
else {
$header = header_hash2string(encode_header($header_hashref));
}
utf8::encode($header);
my $frame;
if ($command eq 'SEND') {
$body = '' unless defined $body;
$frame = $command.$EOL.$header.$EOL.$EOL.$body.$NULL;
}
else {
$frame = $command.$EOL.$header.$EOL.$EOL.$NULL;
}
$self->event('SEND_FRAME', $frame);
$self->event($command, $frame) if ($command =~ m/SEND|ACK|NACK|/);
$self->{handle}->push_write($frame);
$self->reset_client_heartbeat_timer;
}
sub send {
my ($self, $destination, $headers, $body) = @_;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
unless (defined $headers->{'content-type'}) {
carp "It is strongly recommended to set the 'content-type' header.";
}
$self->send_frame('SEND', $headers, $body);
}
sub ack {
my ($self, $ack_id, $transaction) = @_;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
}
my $header = {id => $ack_id,};
$header->{transaction} = $transaction if (defined $transaction);
$self->send_frame('ACK', $header);
}
sub nack {
my ($self, $ack_id, $transaction) = @_;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
}
my $header = {id => $ack_id,};
$header->{transaction} = $transaction if (defined $transaction);
$self->send_frame('NACK', $header);
}
sub send_heartbeat {
my $self = shift;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
if (defined $self->{transactions}{$id}) {
carp "You've already begun transaction '$id'";
}
else {
$self->send_frame('BEGIN', {transaction => $id, %$additional_headers,});
$self->{transactions}{$id} = 1;
}
}
sub commit_transaction {
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
unless (defined $self->{transactions}{$id}) {
carp "You've already commited transaction '$id'";
}
$self->send_frame('COMMIT', {transaction => $id, %$additional_headers,});
delete $self->{transactions}{$id};
}
sub abort_transaction {
my $self = shift;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
unless (defined $self->{transactions}{$id}) {
carp "You've already commited transaction '$id'";
}
$self->send_frame('ABORT', {transaction => $id, %$additional_headers,});
delete $self->{transactions}{$id};
}
sub read_frame {
my $self = shift;
$self->{handle}->unshift_read(
line => sub {
my ($handle, $command, $eol) = @_;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
cb => sub {
my ($handle, $header_string) = @_;
my $header_hashref = header_string2hash($header_string);
my $args;
# The headers of the CONNECTED frame are not en-/decoded
# for backwards compatibility with STOMP 1.0
unless ($command eq 'CONNECTED') {
$header_hashref = decode_header($header_hashref);
}
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
);
}
else {
$self->event('MESSAGE', $header_hashref, $body);
# If frame end was determined by matching
# for a NULL character, then this character
# is not part of the frame body and thus
# removed
if (exists $args->{regex}) {
$body =~ s/\0$//g;
}
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
sub on_connect_error {
return shift->reg_cb('TRANSPORT_CONNECT_ERROR', shift);
}
sub on_send_frame {
return shift->reg_cb('SEND_FRAME', shift);
}
sub on_send {
return shift->reg_cb('SEND', shift);
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
sub on_nack {
return shift->reg_cb('NACK', shift);
}
sub on_read_frame {
return shift->reg_cb('READ_FRAME', shift);
}
sub on_message {
my ($self, $cb, $destination) = @_;
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
AnyEvent::STOMP::Client provides a STOMP (Simple Text Oriented Messaging
Protocol) client. Thanks to AnyEvent, AnyEvent::STOMP::Client is completely
non-blocking, by making extensive use of the AnyEvent::Handle and timers (and,
under the hood, AnyEvent::Socket). Building on Object::Event,
AnyEvent::STOMP::Client implements various events (e.g. the MESSAGE event, when
a STOMP MESSAGE frame is received) and offers callbacks for these (e.g.
on_message($callback)).
=head1 METHODS
=head2 $client = new $host, $port, $connect_headers, $tls_context
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
port where the message broker instance is listening.
=item C<$connect_headers>
Hash, optional, empty by default. May be used to add arbitrary headers to the
STOMP C<CONNECT> frame. STOMP login headers would, for example, be supplied
using this parameter.
=item C<$tls_context>
Hash, optional, undef by default. May be used to supply a SSL/TLS context
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
Connect to the specified STOMP message broker. Croaks if you already
established a connection.
=head2 $client->disconnect
Sends a C<DISCONNECT> STOMP frame to the message broker (if we are still
connected). Croaks, if you are trying to disconnect without actually being
connected.
=over
=item C<$ungraceful>
Boolean, defaults to 0. If the ungraceful option is set, then simply a
C<DISCONNECT> STOMP frame is sent and the connection state is considered to be
disconnected without awaiting any response from the server.
If, however, the option is not set, then a receipt is asked for and the
connection is only considered to be no longer established upon receiving a
receipt for the C<DISCONNECT> frame.
=back
=head2 bool $client->is_connected
Check whether we are still connected to the broker. May only be accurate if
STOMP heart-beats are used.
=head2 $subscription_id = $client->subscribe $destination, $ack_mode, $additional_headers
Subscribe to a destination by sending a C<SUBSCRIBE> STOMP frame to the message
broker. Returns the subscription identifier.
=over
=item C<$destination>
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
C<auto> | C<client> | C<client-individual>, optional, defaults to C<auto>.
See the STOMP documentation for further information on acknowledgement modes.
=item C<$additional_headers>
Used to pass arbitrary headers to the C<SUBSCRIBE> STOMP frame. Broker specific
flow control parameters for example is what would want to supply here.
=back
=head2 $client->unsubscribe $destination, $additional_headers
Unsubscribe from a destination by sending an C<UNSUBSCRIBE> STOMP frame to the
message broker.
=over
=item C<$destination>
String, mandatory. The destination from which we want to unsubscribe.
=item C<$additional_headers>
Used to pass arbitrary headers to the C<UNSUBSCRIBE> STOMP frame.
=back
=head2 $client->send $destination, $headers, $body
Send a STOMP C<SEND> frame to the message broker.
=over
=item C<$destination>
String, mandatory. The destination to which to send the message to.
=item C<$header>
Hash, optional, empty by default. Arbitrary headers included in the C<SEND>
frame. See the STOMP documentation for supported headers.
=item C<$body>
String, optional, empty by default. The body of the message, according to the
content-type specified in the header.
=back
=head2 $client->ack $ack_id, $transaction_id
Send an C<ACK> frame to acknowledge a received message.
=over
=item C<$ack_id>
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
=back
=head2 $client->nack $ack_id, $transaction_id
Send an C<NACK> frame to NOT acknowledge a received message.
=over
=item C<$ack_id>
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
String, mandatory. A unique identifier for the transaction.
=item C<$additional_headers>
Hash, optional, empty by default. Used to pass arbitrary headers to the STOMP
frame.
=back
=head2 $client->commit_transaction $transaction_id, $additional_headers
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
String, mandatory. A unique identifier for the transaction.
=item C<$additional_headers>
Hash, optional, empty by default. Used to pass arbitrary headers to the STOMP
frame.
=back
=head2 $client->abort_transaction $transaction_id, $additional_headers
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
String, mandatory. A unique identifier for the transaction.
=item C<$additional_headers>
Hash, optional, empty by default. Used to pass arbitrary headers to the STOMP
frame.
=back
=head2 $client->destroy
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
In order for the C<AnyEvent::STOMP::Client> to be useful, callback subroutines
can be registered for the following events:
=head3 $guard = $client->on_connected $callback
Invoked when a CONNECTED frame is received. Parameters passed to the callback:
C<$self>, C<$header_hashref>.
=head3 $guard = $client->on_disconnected $callback
Invoked after having successfully disconnected from a broker. I.e. when a
callback is registered for this event and the C<disconnect> subroutine is
called, then a receipt header is included in the DISCONNECT frame and the
disconnected event is fired upon receiving the receipt for the DISCONNECT frame.
Parameters passed to the callback: C<$self>, C<$host>, C<$port>.
=head3 $guard = $client->on_connection_lost $callback
Invoked when either the C<on_error> callback specified in the
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
Invoked when the C<on_connect_error> callback specified in the
C<AnyEvent::Handle> constructor is called.
Parameters passed to the callback: C<$self>, C<$host>, C<$port>.
=head3 $guard = $client->on_send_frame $callback
Invoked when a STOMP frame is sent. Parameters passed to the callback:
C<$self>, C<$frame> (the sent frame as string).
=head3 $guard = $client->on_send $callback
Invoked when a STOMP SEND command is sent. Parameters passed to the callback:
C<$self>, C<$frame> (the sent frame as string).
=head3 $guard = $client->on_ack $callback
Invoked when a STOMP ACK command is sent. Parameters passed to the callback:
C<$self>, C<$frame> (the sent frame as string).
=head3 $guard = $client->on_nack $callback
Invoked when a STOMP NACK command is sent. Parameters passed to the callback:
C<$self>, C<$frame> (the sent frame as string).
=head3 $guard = $client->on_read_frame $callback
Invoked when a STOMP frame is received (irrespective of the STOMP command).
Parameters passed to the callback: C<$self>, C<$command>, C<$header_hashref>,
C<$body> (may be C<undef>, if the frame is not specified to contain a body).
=head3 $guard = $client->on_message $callback $destination
Invoked when a MESSAGE frame is received. Optionally, a C<$destination>
parameter may be specified, resulting in the callback only being invoked,
when a MESSAGE is received from that specific destination.
Parameters passed to the callback: C<$self>, C<$header_hashref>, C<$body>.
=head3 $guard = $client->on_receipt $callback
Invoked when a RECEIPT frame is received. Parameters passed to the callback:
C<$self>, C<$header_hashref>.
=head3 $guard = $client->on_error $callback
Invoked when an ERROR frame is received. Parameters passed to the callback: C<$self>, C<$host>, C<$port>, C<$error_message>.
=head3 $guard = $client->on_subscribed $callback
Invoked after having successfully subscribed to a destination. Works behind the
scenes like the C<on_disconnected> described above. Parameters passed to the
AnyEvent-STOMP
view release on metacpan or search on metacpan
lib/AnyEvent/STOMP.pm view on Meta::CPAN
$client->send($command, $headers, $body);
# Register interest in new messages
$client->reg_cb(MESSAGE => sub {
my (undef, $body, $headers) = @_;
# Do something with the frame
});
# Register interest in any frame received. Use with caution.
$client->reg_cb(frame => sub {
my (undef, $type, $body, $headers) = @_;
# Do something with the frame
});
# Start the event loop
AnyEvent->condvar->recv;
lib/AnyEvent/STOMP.pm view on Meta::CPAN
If defined, subscribe to the specified destination (queue) upon connection.
=item ack
Sets the behavior with respect to STOMP frame acknowledgments.
If this value is 0 or undef, no acknowledgment is required: the server will
consider all sent frames to be delivered, regardless of whether the client has
actually received them. (This is the default behavior according to the STOMP
protocol.)
If set to C<auto>, the client will automatically acknowledge a frame upon
receipt.
If set to C<manual>, the caller must acknowledge frames manually via the
ack() method.
=item connect_headers
An anonymous hash of headers (key/value pairs) to send in the STOMP CONNECT
frame.
=item subscribe_headers
An anonymous hash of headers (key/value pairs) to send in the STOMP SUBSCRIBE
frame.
=back
=cut
lib/AnyEvent/STOMP.pm view on Meta::CPAN
tls => $ssl ? 'connect' : undef,
keepalive => 1,
on_prepare => sub { $self->event('prepare', @_); },
on_connect => sub {
$self->event('connect', @_);
$self->send_frame('CONNECT', undef, $connect_headers);
if ($destination) {
$subscribe_headers->{destination} = $destination;
$subscribe_headers->{ack} = 'client' if $ack;
$connect_cb = $self->reg_cb(CONNECTED => sub {
$self->{session_id} = $_[2]->{session};
$self->send_frame('SUBSCRIBE',
undef, $subscribe_headers);
undef $connect_cb;
});
}
},
lib/AnyEvent/STOMP.pm view on Meta::CPAN
on_error => sub {
$self->unreg_cb($connect_cb) if (defined $connect_cb);
$self->{handle}->destroy;
$self->event('io_error', $_[2]);
},
on_read => sub { $self->_receive_frame },
);
return bless($self, $class);
}
=head2 Sending a message
lib/AnyEvent/STOMP.pm view on Meta::CPAN
my ($body, $destination, $headers) = @_;
croak 'Missing destination' unless defined $destination;
$headers->{destination} = $destination;
$self->send_frame('SEND', $body, $headers);
}
=head2 Sending STOMP frames
You can also send arbitrary STOMP frames:
$client->send_frame($command, $body, $headers); # headers may be undef
See the STOMP protocol documentation for more details on valid commands and
headers.
=head3 Content Length
lib/AnyEvent/STOMP.pm view on Meta::CPAN
The C<content-length> header is special because it is sometimes used to
indicate the length of the body but also the JMS type of the message in
ActiveMQ as per L<http://activemq.apache.org/stomp.html>.
If you do not supply a C<content-length> header, following the protocol
recommendations, a C<content-length> header will be added if the frame has a
body.
If you do supply a numerical C<content-length> header, it will be used as
is. Warning: this may give unexpected results if the supplied value does not
match the body length. Use only with caution!
Finally, if you supply an empty string as the C<content-length> header, it
will not be sent, even if the frame has a body. This can be used to mark a
message as being a TextMessage for ActiveMQ. Here is an example of this:
$client->send_frame($command, $body, { 'content-length' => '' } );
=cut
sub send_frame {
my $self = shift;
my ($command, $body, $headers) = @_;
croak 'Missing command' unless $command;
lib/AnyEvent/STOMP.pm view on Meta::CPAN
$headers->{'content-length'} = length $body;
} elsif ($tmp eq '') {
delete $headers->{'content-length'};
}
my $frame = sprintf("%s\n%s\n%s\000",
$command,
join('', map { "$_:$headers->{$_}\n" } keys %$headers),
$body);
$self->{handle}->push_write($frame);
}
=head2 Events
Once you've connected, you can register interest in events, most commonly
lib/AnyEvent/STOMP.pm view on Meta::CPAN
The typical use is:
$client->reg_cb($type => $cb->($client, $body, $headers));
In most cases, $type is C<MESSAGE>, but you can also register interest
in any other type of frame (C<RECEIPT>, C<ERROR>, etc.). (If you register
interest in C<CONNECTED> frames, please do so with a priority of C<after>;
see Object::Event for more details.)
The client object (which can usually be ignored), body and headers (as an
anonymous hash of key-value pairs) will be passed to your callback.
lib/AnyEvent/STOMP.pm view on Meta::CPAN
=item connect => $cb->($client, $handle, $host, $port, $retry->())
Will be fired when the client has successfully connected to the STOMP server.
See C<on_connect> in AnyEvent::Handle for more details.
=item frame => $cb->($client, $type, $body, $headers)
Will be fired whenever any frame is received.
=item connect_error => $cb->($client, $errmsg)
Will be fired if the attempt to connect to the STOMP server fails. See
C<on_connect_error> in AnyEvent::Handle for more details.
lib/AnyEvent/STOMP.pm view on Meta::CPAN
=back
=cut
sub _receive_frame {
my $self = shift;
my $command;
my $headers = {};
my $body;
lib/AnyEvent/STOMP.pm view on Meta::CPAN
$self->{handle}->unshift_read(@args, sub {
$body = $_[1];
$body =~ s/\000\n*$//;
if ($self->{ack} eq 'auto' && defined $headers->{'message-id'}) {
$self->send_frame('ACK', undef,
{'message-id' => $headers->{'message-id'}});
}
$self->event($command, $body, $headers);
$self->event('frame', $command, $body, $headers);
});
});
}
=head2 Acknowledging frames
You can acknowledge a frame received via the ack() method:
$client->ack($id, $transaction);
The transaction is optional.
lib/AnyEvent/STOMP.pm view on Meta::CPAN
croak 'Missing ID' unless $id;
my $headers = { 'message-id' => $id };
$headers->{transaction} = $transaction if defined $transaction;
$self->send_frame('ACK', undef, $headers);
}
=head2 Closing a session
When done with a session, you need to explicitly call the destroy() method.
lib/AnyEvent/STOMP.pm view on Meta::CPAN
=cut
sub destroy {
my ($self) = shift;
$self->send_frame('DISCONNECT') if defined undef $self->{handle};
undef $self->{handle};
}
=head1 SEE ALSO
AnyEvent-Semaphore
view release on metacpan or search on metacpan
lib/AnyEvent/Semaphore.pm view on Meta::CPAN
=head1 DESCRIPTION
This module provides a semaphore implementation intended to be used
with the L<AnyEvent> framework.
It tries to be as simple as possible and to follow AnyEvent style.
=head2 API
AnyEvent-Stomper
view release on metacpan or search on metacpan
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $headers;
return sub {
my $handle = shift;
my $frame;
while (1) {
return if $handle->destroyed;
if ( defined $cmd_name ) {
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
my $body = substr( $handle->{rbuf}, 0, $content_length, '' );
$handle->{rbuf} =~ s/^\0(?:${\(RE_EOL)})*//;
$frame = _new_frame( $cmd_name, $headers, $body );
undef $cmd_name;
undef $headers;
}
else {
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
next;
}
$self->_process_frame($frame);
}
};
}
sub _prepare {
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
unless ( defined $cmd_headers->{'content-length'} ) {
$cmd_headers->{'content-length'} = length($body);
}
my $frame_str = $cmd->{name} . EOL;
while ( my ( $name, $value ) = each %{$cmd_headers} ) {
unless ( defined $value ) {
$value = '';
}
$frame_str .= _escape($name) . ':' . _escape($value) . EOL;
}
$frame_str .= EOL . "$body\0";
$self->{_handle}->push_write($frame_str);
return;
}
sub _login {
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
return;
}
sub _process_frame {
my $self = shift;
my $frame = shift;
if ( $frame->command eq 'MESSAGE' ) {
$self->_process_message($frame);
}
elsif ( $frame->command eq 'RECEIPT' ) {
$self->_process_receipt($frame);
}
elsif ( $frame->command eq 'ERROR' ) {
if ( defined $self->{_pending_receipts}{CONNECTED} ) {
$frame->headers->{'receipt-id'} = 'CONNECTED';
}
$self->_process_error($frame);
}
else { # CONNECTED
$frame->headers->{'receipt-id'} = 'CONNECTED';
$self->_process_receipt($frame);
}
return;
}
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $sub_id = $msg_headers->{subscription} || $msg_headers->{destination};
my $sub = $self->{_subs}{$sub_id};
unless ( defined $sub ) {
my $err = _new_error(
qq{Don't know how process MESSAGE frame. Unknown subscription "$sub_id"},
E_UNEXPECTED_DATA
);
$self->_disconnect($err);
return;
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $receipt_id = $receipt->headers->{'receipt-id'};
my $cmd = delete $self->{_pending_receipts}{$receipt_id};
unless ( defined $cmd ) {
my $err = _new_error(
qq{Unknown RECEIPT frame received: receipt-id=$receipt_id},
E_UNEXPECTED_DATA
);
$self->_disconnect($err);
return;
lib/AnyEvent/Stomper.pm view on Meta::CPAN
return;
}
sub _process_error {
my $self = shift;
my $err_frame = shift;
my $err_headers = $err_frame->headers;
my $err = _new_error( $err_headers->{message}, E_OPRN_ERROR, $err_frame );
my $cmd;
if ( defined $err_headers->{'receipt-id'} ) {
$cmd = delete $self->{_pending_receipts}{ $err_headers->{'receipt-id'} };
}
lib/AnyEvent/Stomper.pm view on Meta::CPAN
}
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
$self->{on_error}->($err);
if ( %subs && $err_code != E_CONN_CLOSED_BY_CLIENT ) {
foreach my $sub_id ( keys %subs ) {
my $err = _new_error( qq{Subscription "$sub_id" lost: $err_msg},
$err_code, $err_frame );
my $sub = $subs{$sub_id};
$sub->{on_receipt}->( undef, $err );
}
}
foreach my $cmd (@queued_commands) {
my $err = _new_error( qq{Operation "$cmd->{name}" aborted: $err_msg},
$err_code, $err_frame );
$cmd->{on_receipt}->( undef, $err );
}
}
return;
lib/AnyEvent/Stomper.pm view on Meta::CPAN
$str =~ s/(\\[rnc\\])/$UNESCAPE_MAP{$1}/ge;
return $str;
}
sub _new_frame {
return AnyEvent::Stomper::Frame->new(@_);
}
sub _new_error {
return AnyEvent::Stomper::Error->new(@_);
lib/AnyEvent/Stomper.pm view on Meta::CPAN
Enabling of the C<autocork> parameter can improve performance. See
documentation on L<AnyEvent::Handle> for more information.
=item default_headers => \%headers
Specifies default headers for all outgoing frames.
default_headers => {
'x-foo' => 'foo_value',
'x-bar' => 'bar_value',
}
lib/AnyEvent/Stomper.pm view on Meta::CPAN
=head1 COMMAND METHODS
To execute the STOMP command you must call appropriate method. STOMP headers
can be specified as command parameters. The client automatically adds
C<content-length> header to all outgoing frames. Every command method can also
accept two additional parameters: the C<body> parameter where you can specify
the body of the frame, and the C<on_receipt> parameter that is the alternative
way to specify the command callback.
If you want to receive C<RECEIPT> frame, you must specify C<receipt> header.
The C<receipt> header can take the special value C<auto>. If it set, the
receipt identifier will be generated automatically by the client. The
C<RECEIPT> frame is passed to the command callback in first argument as the
object of the class L<AnyEvent::Stomper::Frame>. If the C<receipt> header is
not specified the first argument of the command callback will be C<undef>.
For commands C<SUBSCRIBE>, C<UNSUBSCRIBE>, C<DISCONNECT> the client
automatically adds C<receipt> header for internal usage.
The command callback is called in one of two cases depending on the presence of
the C<receipt> header. First case, when the command was successfully written to
the socket. Second case, when the C<RECEIPT> frame will be received. In first
case C<on_receipt> callback can be called synchronously. If any error occurred
during the command execution, the error object is passed to the callback in
second argument. Error object is the instance of the class
L<AnyEvent::Stomper::Error>.
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $err = $_[1];
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
# error handling...
return;
}
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $err = shift;
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
# error handling...
return;
}
lib/AnyEvent/Stomper.pm view on Meta::CPAN
=head2 subscribe( [ %params ] [, $cb->( $msg ) ] )
The method is used to register to listen to a given destination. The
C<subscribe> method require the C<on_message> callback, which is called on
every received C<MESSAGE> frame from the server. The C<MESSAGE> frame is passed
to the C<on_message> callback in first argument as the object of the class
L<AnyEvent::Stomper::Frame>. If the C<subscribe> method is called with one
callback, this callback will be act as C<on_message> callback.
$stomper->subscribe(
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $err = shift;
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
return;
}
# receipt handling...
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $err = shift;
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
return;
}
# receipt handling...
lib/AnyEvent/Stomper.pm view on Meta::CPAN
The method is used to acknowledge consumption of a message from a subscription
using C<client> or C<client-individual> acknowledgment. Any messages received
from such a subscription will not be considered to have been consumed until the
message has been acknowledged via an C<ack()> method. Method C<ack()> must be
called with required parameter C<message> in which must be specified the
C<MESSAGE> frame.
$stomper->ack( message => $msg );
$stomper->ack(
message => $msg,
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $err = shift;
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
# error handling...
}
# receipt handling...
lib/AnyEvent/Stomper.pm view on Meta::CPAN
=head2 nack( [ %params ] [, $cb->( $receipt, $err ) ] )
The C<nack> method is the opposite of C<ack> method. It is used to tell the
server that the client did not consume the message. Method C<nack()> must be
called with required parameter C<message> in which must be specified the
C<MESSAGE> frame.
$stomper->nack( message => $msg );
$stomper->nack(
message => $msg,
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $err = shift;
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
# error handling...
}
# receipt handling...
lib/AnyEvent/Stomper.pm view on Meta::CPAN
The method C<abort> is used to roll back a transaction.
=head2 disconnect( [ %params ] [, $cb->( $receipt, $err ) ] )
A client can disconnect from the server at anytime by closing the socket but
there is no guarantee that the previously sent frames have been received by
the server. To do a graceful shutdown, where the client is assured that all
previous frames have been received by the server, you must call C<disconnect>
method and wait for the C<RECEIPT> frame.
=head2 execute( $command, [ %params ] [, $cb->( $receipt, $err ) ] )
An alternative method to execute commands. In some cases it can be more
convenient.
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $err = shift;
if ( defined $err ) {
my $err_msg = $err->message;
my $err_code = $err->code;
my $err_frame = $err->frame;
# error handling...
return;
}
AnyEvent-Task
view release on metacpan or search on metacpan
lib/AnyEvent/Task.pm view on Meta::CPAN
Both client and server are of course built with L<AnyEvent>. However, workers can't use AnyEvent (yet). I've never found a need to do event processing in the worker since if the library you wish to use is already AnyEvent-compatible you can simply us...
Each client maintains a "pool" of connections to worker processes. Every time a checkout is requested, the request is placed into a first-come, first-serve queue. Once a worker process becomes available, it is associated with that checkout until that...
C<timeout> can be passed as a keyword argument to C<checkout>. Once a request is queued up on that checkout, a timer of C<timout> seconds (default is 30, undef means infinity) is started. If the request completes during this timeframe, the timer is c...
Note that since timeouts are associated with a checkout, checkouts can be created before the server is started. As long as the server is running within C<timeout> seconds, no error will be thrown and no requests will be lost. The client will continua...
Because of checkout queuing, the maximum number of worker processes a client will attempt to obtain can be limited with the C<max_workers> argument when creating a client object. If there are more live checkouts than C<max_workers>, the remaining che...
lib/AnyEvent/Task.pm view on Meta::CPAN
But in an asynchronous program, typically C<hash> would initiate some kind of asynchronous operation and then return immediately, allowing the program to go about other tasks while waiting for the result. Since the error might come back at any time i...
AnyEvent::Task accomplishes this mapping with L<Callback::Frame>.
Callback::Frame lets you preserve error handlers (and C<local> variables) across asynchronous callbacks. Callback::Frame is not tied to AnyEvent::Task, AnyEvent or any other async framework and can be used with almost all callback-based libraries.
However, when using AnyEvent::Task, libraries that you use in the client must be L<AnyEvent> compatible. This restriction obviously does not apply to your server code, that being the main purpose of this module: accessing blocking resources from an a...
As an example usage of Callback::Frame, here is how we would handle errors thrown from a worker process running the C<hash> method in an asychronous client program:
use Callback::Frame;
frame(code => sub {
$client->checkout->hash('secret', sub {
my ($checkout, $crypted) = @_;
say "Hashed password is $crypted";
});
lib/AnyEvent/Task.pm view on Meta::CPAN
my $back_trace = shift;
say "Error is: $@";
say "Full back-trace: $back_trace";
})->(); ## <-- frame is created and then immediately executed
Of course if C<hash> is something like a bcrypt hash function it is unlikely to raise an exception so maybe that's a bad example. On the other hand, maybe it's a really good example: In addition to errors that occur while running your callbacks, L<An...
lib/AnyEvent/Task.pm view on Meta::CPAN
In servers, Callback::Frame helps you maintain the "dynamic state" (error handlers and dynamic variables) installed for a single connection. In other words, any errors that occur while servicing that connection will be able to be caught by an error h...
Callback::Frame provides an error handler stack so you can have a top-level handler as well as nested handlers (similar to nested C<eval>s). This is useful when you wish to have a top-level "bail-out" error handler and also nested error handlers that...
Callback::Frame is designed to be easily used with callback-based libraries that don't know about Callback::Frame. C<fub> is a shortcut for C<frame> with just the C<code> argument. Instead of passing C<sub { ... }> into libraries you can pass in C<fu...
It's important that all callbacks be created with C<fub> (or C<frame>) even if you don't expect them to fail so that the dynamic context is preserved for nested callbacks that may. An exception is the callbacks provided to AnyEvent::Task checkouts: T...
The L<Callback::Frame> documentation explains how this works in much more detail.
lib/AnyEvent/Task.pm view on Meta::CPAN
- start delivering fatal errors to some (at front of queue or back of queue though?)
- write test for this
! docs: write good error handling examples
Make names more consistent between callback::frame backtraces and auto-generated log::defer timers
make server not use AnyEvent so don't have to worry about workers unlinking unix socket in dtors
In a graceful shutdown scenario, servers wait() on all their children before terminating.
- Support relinquishing accept() socket during this period?
AnyEvent-WebDriver
view release on metacpan or search on metacpan
WebDriver.pm view on Meta::CPAN
our $VERSION = '1.2';
our $WEB_ELEMENT_IDENTIFIER = "element-6066-11e4-a52e-4f735466cecf";
our $WEB_WINDOW_IDENTIFIER = "window-fcc6-11e5-b4f8-330a88ab9d7f";
our $WEB_FRAME_IDENTIFIER = "frame-075b-4da1-b6ba-e579c2d3230a";
my $json = eval { require JSON::XS; JSON::XS:: } || do { require JSON::PP; JSON::PP:: };
$json = $json->new->utf8;
$json->boolean_values (0, 1)
WebDriver.pm view on Meta::CPAN
sub get_window_handles_ {
$_[0]->get_ ("window/handles" => $_[1]);
}
=item $handles = $wd->switch_to_frame ($frame)
Switch to the given frame identified by C<$frame>, which must be either
C<undef> to go back to the top-level browsing context, an integer to
select the nth subframe, or an element object.
=cut
sub switch_to_frame_ {
$_[0]->post_ (frame => { id => "$_[1]" }, $_[2]);
}
=item $handles = $wd->switch_to_parent_frame
Switch to the parent frame.
=cut
sub switch_to_parent_frame_ {
$_[0]->post_ ("frame/parent" => undef, $_[1]);
}
=item $rect = $wd->get_window_rect
Return the current window rect(angle), e.g.:
AnyEvent-WebService-Notifo
view release on metacpan or search on metacpan
lib/AnyEvent/WebService/Notifo.pm view on Meta::CPAN
$awn->send_notification(msg => 'my nottification text', cb => $cv);
$res = $cv->recv; # $res is our response
=head1 DESCRIPTION
A client for the L<http://notifo.com/> API using the L<AnyEvent> framework.
=head1 CONSTRUCTORS
=head2 new
AnyEvent-WebSocket-Client
view release on metacpan or search on metacpan
lib/AnyEvent/WebSocket/Client.pm view on Meta::CPAN
Although, the order cannot be guaranteed when using the hash style.
=head2 max_payload_size
The maximum payload size for received frames. Currently defaults to whatever
L<Protocol::WebSocket> defaults to.
=head2 max_fragments
The maximum number of fragments for received frames. Currently defaults to whatever
L<Protocol::WebSocket> defaults to.
=head2 env_proxy
If you set true to this boolean attribute, it loads proxy settings
AnyEvent-WebSocket-Server
view release on metacpan or search on metacpan
lib/AnyEvent/WebSocket/Server.pm view on Meta::CPAN
If this option is set, L<AnyEvent::WebSocket::Server> encrypts the WebSocket streams with SSL/TLS.
=item C<max_payload_size> => INT (optional)
The maximum payload size for received frames. Currently defaults to whatever L<Protocol::WebSocket> defaults to.
Note that payload size for sent frames are not limited.
=back
=head1 OBJECT METHODS
AnyEvent-XMPP
view release on metacpan or search on metacpan
lib/AnyEvent/XMPP.pm view on Meta::CPAN
use AnyEvent::XMPP::Client;
=head1 DESCRIPTION
This is the head module of the L<AnyEvent::XMPP> XMPP client protocol (as described in
RFC 3920 and RFC 3921) framework.
L<AnyEvent::XMPP::Connection> is a RFC 3920 conforming "XML" stream implementation
for clients, which handles TCP connect up to the resource binding. And provides
low level access to the XML nodes on the XML stream along with some high
level methods to send the predefined XML stanzas.
lib/AnyEvent/XMPP.pm view on Meta::CPAN
For a list of L</Supported extensions> see below.
There are also other modules in this distribution, for example:
L<AnyEvent::XMPP::Util>, L<AnyEvent::XMPP::Writer>, L<AnyEvent::XMPP::Parser> and those I
forgot :-) Those modules might be helpful and/or required if you want to use
this framework for XMPP.
See also L<AnyEvent::XMPP::Writer> for a discussion about the brokenness of XML in the XMPP
specification.
If you have any questions or seek for help look below under L</SUPPORT>.
lib/AnyEvent/XMPP.pm view on Meta::CPAN
The other modules could often only be integrated in those applications or
libraries by using threads. I decided to write this module because I think CPAN
lacks an event based XMPP module. Threads are unfortunately not an alternative
in Perl at the moment due the limited threading functionality they provide and
the global speed hit. I also think that a simple event based I/O framework
might be a bit easier to handle than threads.
Another thing was that I didn't like the APIs of the other modules. In
L<AnyEvent::XMPP> I try to provide low level modules for speaking XMPP as defined
in RFC 3920 and RFC 3921 (see also L<AnyEvent::XMPP::Connection> and
AnyEvent-mDNS
view release on metacpan or search on metacpan
lib/AnyEvent/mDNS.pm view on Meta::CPAN
warn "Found $service->{name} ($service->{proto}) running on $service->{host}:$service->{port}\n";
}
=head1 DESCRIPTION
AnyEvent::mDNS is a multicast DNS resolver using AnyEvent framework.
=head1 METHODS
=over 4
AnyMQ-AMQP
view release on metacpan or search on metacpan
lib/AnyMQ/Trait/AMQP.pm view on Meta::CPAN
my $rf = AnyEvent::RabbitMQ->new(timeout => 1, verbose => 0);
$self->_rf($rf);
# XXX: wrapped object with monadic method modifier
# my $channel = run_monad { $rf->connect(....)->open_channel()->return }
# my $queue = run_monad { $channel->declare_queue(....)->return }->method_frame->queue;
# run_monad { $channel->consume( ....) }
my $init = sub {
my $channel = shift;
$channel->declare_queue(
exclusive => 1,
on_success => sub {
my $method = shift;
my $queue = $method->method_frame->queue;
$self->_rf_queue($queue);
$channel->consume(queue => $queue,
no_ack => 1,
on_success => sub {
$cv->send('init');
lib/AnyMQ/Trait/AMQP.pm view on Meta::CPAN
}
sub on_consume {
my $self = shift;
sub {
my $frame = shift;
my $payload = $frame->{body}->payload;
my $reply_to = $frame->{header}->reply_to;
return if $reply_to && $reply_to eq $self->_rf_queue;
my $topic = $frame->{deliver}->method_frame->routing_key;
try { $self->topics->{$topic}->AnyMQ::Topic::publish(JSON::from_json($payload)) }
catch { croak "failed to republsih on $topic: $_" };
};
}
Apache-ASP
view release on metacpan or search on metacpan
This API was created to allow developers easy XSLT component
rendering without having to render the entire ASP scripts
via XSLT. This will make an easy plugin architecture for
those looking to integrate XML into their existing ASP
application frameworks.
At some point, the API will likely take files as arguments,
but not as of the 2.11 release.
=back
Apache Web Server
http://www.apache.org
=head1 TODO
There is no specific time frame in which these things will be
implemented. Please let me know if any of these is of particular
interest to you, and I will give it higher priority.
=head2 WILL BE DONE
functions from Fnctl.
+SessionQueryParse & SessionQueryParseMatch
settings that enable auto parsing session ids into
URLs for cookieless sessions. Will pick up URLs in
<a href>, <area href>, <form action>, <frame src>,
<iframe src>, <img src>, <input src>, <link href>
$Response->Redirect($URL) and the first URL in
script tags like <script>*.location.href=$URL</script>
These settings require that buffering be enabled, as
Apache::ASP will parse through the buffer to parse the URLs.
Apache-AntiSpam-JavaScript
view release on metacpan or search on metacpan
JavaScript.pm view on Meta::CPAN
'm.de'+'"'+JSgt+'al'+'ex@z'+'eitf'+'orm.'+'de'+JSlt+'/'+
'a'+JSgt+'');
</script>
This module is Filter aware, meaning that it can work within
Apache::Filter framework without modification.
You may want to use other Apache::AntiSpam::* modules after this one.
This work is based on the Apache::AntiSpam::* modules provided by
Tatsuhiko Miyagawa E<lt>miyagawa@bulknews.netE<gt>.
Apache-AntiSpam-SpamTrap
view release on metacpan or search on metacpan
SpamTrap.pm view on Meta::CPAN
For example, C<apleiner@cpan.org> will be filtered to
C<apleiner-78c1ed6da0322b3a@cpan.org>.
This module is Filter aware, meaning that it can work within
Apache::Filter framework without modification.
You need to give the Blowfish key in your Apache configuration file.
To decode a received mail's SpamTrap string use the following function:
Apache-AntiSpam
view release on metacpan or search on metacpan
lib/Apache/AntiSpam.pm view on Meta::CPAN
Apache::AntiSpam is a filter module to prevent e-mail addresses
exposed as is on web pages. The way to hide addresses from spammers
are implemented in each of Apache::Antispam::* subclasses.
This module is Filter aware, meaning that it can work within
Apache::Filter framework without modification.
=head1 SUBCLASSING
Here is how to make your own filter.
Apache-App-Mercury
view release on metacpan or search on metacpan
# first, edit Apache/App/Mercury/Config.pm and set variables appropriately
# from the mod_perl handler of your application
# Note: in these examples My::MVC::Controller is assumed to be a class
# which provides a persistence framework so object variables are kept
# across http requests; it also must implement some predefined methods
# (see below for details on these methods)
$controller = My::MVC::Controller->new;
$controller->handler;
...
Apache-AppSamurai
view release on metacpan or search on metacpan
lib/Apache/AppSamurai.pm view on Meta::CPAN
browser. Only authenticated and authorized requests are proxied through
to the backend server.
Apache::AppSamurai is based on, and includes some code from,
L<Apache::AuthCookie|Apache::AuthCookie>.
Upon that core is added a full authentication and session handling framework.
(No coding required.) Features include:
=over 4
=item *
lib/Apache/AppSamurai.pm view on Meta::CPAN
=head2 SESSION CONFIGURATION
Each Apache::AppSamurai instance must have its local (proxy server side)
session handling defined.
L<Apache::Session|Apache::Session> provides the majority of the session
framework. Around Apache::Session is wrapped
L<Apache::AppSamurai::Session|Apache::AppSamurai::Session>, which
adds features to allow for more flexible selection of sub-modules.
Most Apache::Session style configuration options can be passed directly to the
session system by prefixing them with C<authnameSession>.
Apache-AuthCookie
view release on metacpan or search on metacpan
- login(): set Location header with err_headers_out rather than headers_out
(Casey West)
- put cookie removal code in remove_cookie() method, put cache handling
code in handle_cache() (Mark A. Hershberger)
- reorganized tree to support multiple mod_perl versions.
- rewrote tests to use Apache::Test framework from CPAN.
- fix POD errors in authorize() documentation.
- initial support for mod_perl version 2
- mp2: check for Apache::RequestRec arg so that unported subclasses
throw exceptions.
Apache-AuthDigest
view release on metacpan or search on metacpan
use Apache::TestRequest;
plan tests => 4, have_lwp;
# most of this is taken right from
# perl-framework/t/http11/basicauth.t
#
# many kudos to LWP for supporting Digest authentication natively!
my $url = '/protected/index.html';
Apache-AuthenCache
view release on metacpan or search on metacpan
AuthenCache.pm view on Meta::CPAN
return DECLINED;
}
# Password matches so end stage
# The required patch was not introduced in 1.26. It is no longer
# promised to be included in any timeframe. Commenting out.
# if ($mod_perl::VERSION > 1.25) {
# I should be able to use the below lines and be done with it.
# Since set_handlers() doesn't work properly until 1.26
# (according to Doug MacEachern) I have to work around it by
# cobbling together cheat sheets for the subsequent handlers
AuthenCache.pm view on Meta::CPAN
# Get username
my $user_sent = $r->connection->user;
$r->log->debug("manage_cache: username=$user_sent");
# The required patch was not introduced in 1.26. It is no longer
# promised to be included in any timeframe. Commenting out.
# unless ($mod_perl::VERSION > 1.25) {
# The below test is dubious. I'm putting it in as a hack around the
# problems with set_handlers not working quite right until 1.26 is
# released (according to Doug MacEachern).
my $cache_result = $r->notes('AuthenCache');
( run in 1.923 second using v1.01-cache-2.11-cpan-df04353d9ac )