AnyEvent-RabbitMQ-Fork

 view release on metacpan or  search on metacpan

lib/AnyEvent/RabbitMQ/Fork.pm  view on Meta::CPAN

  my $cv = AnyEvent->condvar;

  my $ar = AnyEvent::RabbitMQ::Fork->new->load_xml_spec()->connect(
      host       => 'localhost',
      port       => 5672,
      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;
                  $channel->declare_exchange(
                      exchange   => 'test_exchange',
                      on_success => sub {
                          $cv->send('Declared exchange');
                      },
                      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;
          }
      },
  );

  print $cv->recv, "\n";

=cut

lib/AnyEvent/RabbitMQ/Fork.pm  view on Meta::CPAN

=item B<tls> Boolean to use SSL/TLS or not. Default: 0

=item B<tune> Hash: (values are negotiated with the server)

=over

=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.

=item B<on_failure> Called when a failure occurs over the lifetime of the connection.

=item B<on_read_failure> Called when there is a problem reading response from the server.

=item B<on_return> Called if the server returns a published message.

lib/AnyEvent/RabbitMQ/Fork/Channel.pm  view on Meta::CPAN

=head1 ATTRIBUTES

=over

=item B<id> Numerical ID assigned by the connection object and used in
coordination with the server.

=item B<is_open> Indicator if this channel is open for use.

=item B<is_active> Indicator if the server has sent a C<Channel.Flow> frame as
a form of throttle control. Will be true if that is the case.

=item B<is_confirm> Indicator if the channel is in confirm mode, meaning the
server will Ack/Nack/Return every message published.

=back

=cut

has id         => (is => 'ro', isa => Int);

t/release-04_anyevent.t  view on Meta::CPAN

    $z->connect(
        (map { $_ => $conf{$_} } qw(host port user pass vhost)),
        timeout    => 1,
        on_success => sub {
            my $ar = shift;
            isa_ok($ar, 'AnyEvent::RabbitMQ::Fork');
            $done->send;
        },
        on_failure => failure_cb($done),
        on_return  => sub {
            my $method_frame = shift->method_frame;
            die "return: ", $method_frame->reply_code, $method_frame->reply_text
              if $method_frame->reply_code;
        },
        on_close => sub {
            my $method_frame = shift->method_frame;
            Carp::confess "close: ", $method_frame->reply_code, $method_frame->reply_text
              if $method_frame->reply_code;
        },
        @{$opt},
    );
    $done->recv;
}

my $done = AnyEvent->condvar;
$ar->connect(
    (map { $_ => $conf{$_} } qw(host port user pass vhost)),
    tune       => { frame_max => 2**17 },
    timeout    => 1,
    on_success => sub {
        my $ar = shift;
        isa_ok($ar, 'AnyEvent::RabbitMQ::Fork');
        $server{product} = $ar->server_properties->{product};
        $server{version} = version->parse($ar->server_properties->{version});
        $done->send;
    },
    on_failure => failure_cb($done),
    on_return  => sub {
        my $method_frame = shift->method_frame;
        die "return: ", $method_frame->reply_code, $method_frame->reply_text
          if $method_frame->reply_code;
    },
    on_close => sub {
        my $method_frame = shift->method_frame;
        Carp::confess "close: ", $method_frame->reply_code, $method_frame->reply_text
          if $method_frame->reply_code;
    },
);
$done->recv;

our $ch;
$done = AnyEvent->condvar;
open_ch($done);
$done->recv;

sub open_ch {
    my ($cv,) = @_;
    $ar->open_channel(
        on_success => sub {
            $ch = shift;
            isa_ok($ch, 'AnyEvent::RabbitMQ::Fork::Channel');
            $cv->send;
        },
        on_failure => failure_cb($cv),
        on_close   => sub {
            my $method_frame = shift->method_frame;
            die $method_frame->reply_code, $method_frame->reply_text
              if $method_frame->reply_code;
        },
    );
}

$done = AnyEvent->condvar;
$ch->declare_exchange(
    exchange   => 'test_x',
    on_success => sub {
        pass('declare exchange');
        $done->send;

t/release-04_anyevent.t  view on Meta::CPAN

    on_failure => failure_cb($done),
);
$done->recv;
pass('confirm');

$done = AnyEvent->condvar;
my $consumer_tag;
$ch->consume(
    queue      => 'test_q',
    on_success => sub {
        my $frame = shift;
        $consumer_tag = $frame->method_frame->consumer_tag;
        pass('consume');
    },
    on_consume => sub {
        my $response = shift;
        ok($response->{body}->payload, 'publish');
        $done->send;
    },
    on_failure => failure_cb($done),
);
publish($ch, 'Hello RabbitMQ.', $done,);

t/release-04_anyevent.t  view on Meta::CPAN

$done = AnyEvent->condvar;
publish($ch, 'NO RabbitMQ, NO LIFE.', $done,);
$done->recv;
$done = AnyEvent->condvar;
$ch->consume(
    queue      => 'test_q',
    no_ack     => 0,
    on_consume => sub {
        my $response = shift;
        $ch->ack(delivery_tag => $response->{deliver}->method_frame->delivery_tag);
        pass('ack deliver');

        $ch->cancel(
            consumer_tag => $response->{deliver}->method_frame->consumer_tag,
            on_success   => sub {
                pass('cancel');
                $done->send;
            },
            on_failure => failure_cb($done),
        );
    },
    on_failure => failure_cb($done),
);
$done->recv;

$done = AnyEvent->condvar;
publish($ch, 'RabbitMQ is cool.', $done,);
$done->recv;
$done = AnyEvent->condvar;
$ch->get(
    queue      => 'test_q',
    no_ack     => 0,
    on_success => sub {
        my $response = shift;
        $ch->ack(delivery_tag => $response->{ok}->method_frame->delivery_tag);
        pass('ack get');
        $done->send;
    },
    on_failure => failure_cb($done),
);
$done->recv;

$done = AnyEvent->condvar;
my @responses;
$ch->qos(

t/release-04_anyevent.t  view on Meta::CPAN

$pub_done->begin;
$pub_done->begin;
$pub_done->begin;
publish($ch, 'RabbitMQ is excellent.', AnyEvent->condvar(sub { $pub_done->end }),);
publish($ch, 'RabbitMQ is fantastic.', AnyEvent->condvar(sub { $pub_done->end }),);
$pub_done->end;
$done->recv;
pass('qos');

for my $response (@responses) {
    $ch->ack(delivery_tag => $response->{deliver}->method_frame->delivery_tag,);
}

$done = AnyEvent->condvar;
$ch->cancel(
    consumer_tag => $responses[0]->{deliver}->method_frame->consumer_tag,
    on_success   => sub {
        $ch->qos(
            on_success => sub {
                $done->send;
            },
            on_failure => failure_cb($done),
        );
    },
    on_failure => failure_cb($done),
);

t/release-04_anyevent.t  view on Meta::CPAN

    queue      => 'test_q',
    no_ack     => 0,
    on_consume => sub {
        my $response = shift;

        if (5 > ++$recover_count) {
            $ch->recover();
            return;
        }

        $ch->ack(delivery_tag => $response->{deliver}->method_frame->delivery_tag);

        $ch->cancel(
            consumer_tag => $response->{deliver}->method_frame->consumer_tag,
            on_success   => sub {
                $done->send;
            },
            on_failure => failure_cb($done),
        );
    },
    on_failure => failure_cb($done),
);
$done->recv;
pass('recover');

t/release-04_anyevent.t  view on Meta::CPAN

    $done = AnyEvent->condvar;
    my $reject_count = 0;
    $ch->consume(
        queue      => 'test_q',
        no_ack     => 0,
        on_consume => sub {
            my $response = shift;

            if (5 > ++$reject_count) {
                $ch->reject(
                    delivery_tag => $response->{deliver}->method_frame->delivery_tag,

                    # requeue! Else the server does not deliver the message again to this client.
                    requeue => 1,
                );
                return;
            }

            $ch->ack(delivery_tag => $response->{deliver}->method_frame->delivery_tag);

            $ch->cancel(
                consumer_tag => $response->{deliver}->method_frame->consumer_tag,
                on_success   => sub {
                    $done->send;
                },
                on_failure => failure_cb($done),
            );
        },
        on_failure => failure_cb($done),
    );
    my $pub_done = AnyEvent->condvar;
    publish($ch, 'RabbitMQ is powerful.', $pub_done,);

t/release-05_hiload.t  view on Meta::CPAN

    sub {
        my $message = shift;

        my $i = $message->{body}->payload;

        unless (++$count % TO_CHECK) {
            cmp_ok $i, q{==}, $count, "saw message $i in order";
        }

        $consumer_ch->ack(
            delivery_tag => $message->{deliver}->method_frame->delivery_tag);

        $final->send('fin') if $i == TO_SEND;
    };
};

my $cv = AE::cv;

my $consumer
  = AnyEvent::RabbitMQ::Fork->new(verbose => VERBOSE)->load_xml_spec->connect(
    host       => 'localhost',

t/release-05_multi_channel.t  view on Meta::CPAN

    $ch->publish(
        routing_key => $queue,
        body        => $message,
        mandatory   => 1,
    );

    return;
}

sub handle_close {
    my $method_frame = shift->method_frame;
    die $method_frame->reply_code, $method_frame->reply_text
      if $method_frame->reply_code;
}