root/lang/perl/XMPP-Bomber/trunk/lib/XMPP/Bomber.pm @ 13216

# $Id$

package XMPP::Bomber;
use Moose;
use XMPP::Bomber::Types;

has 'clients' => (
    is => 'rw',
    isa => 'ClientList',
    auto_deref => 1,
    coerce => 1,
    required => 1,
);

has 'condvar' => (
    is => 'rw',
    default => sub { AnyEvent->condvar(cb => \&child_exited) }
);

no Moose;

use AnyEvent;
# use AnyEvent::Impl::Perl;
use Net::XMPP2;
use Net::XMPP2::Client;
use XMPP::Bomber::Account;
use XMPP::Bomber::Sender;
use XMPP::Bomber::Receiver;

our $VERSION = '0.00001';

sub run
{
    my ($self) = @_;

    $self->run_clients;

    wait();
}

sub run_clients
{
    my $self = shift;

    foreach my $client ($self->clients) {
        my $pid = fork();
        if (! defined $pid) {
            die "Failed to fork!";
        }

        if (! $pid ) {
            eval {
                $client->run;
            };
            exit $@ ? 1 : 0;
        }
    }
}

sub start_receivers
{
    my $self = shift;

    my $provider = $self->receiver_provider;
    while (my $account = $provider->create) {
        my $receiver = XMPP::Bomber::Receiver->new(
            hostname => $self->hostname,
            port     => $self->port,
            domain   => $self->domain,
            account  => $account
        );

        $receiver->start;

        AnyEvent->child(
            pid => $receiver->pid,
            cb  => sub { $self->condvar->send($self) }
        );
        push @{$self->receivers}, $receiver;
    }
}

sub stop_receivers
{
    my $self = shift;
    my $receiver_count = $self->receiver_count;
    foreach my $receiver ( @{ $self->receivers } ) {
        $receiver->stop;
    }
        
}

sub child_exited { die "exited @_" }

sub start_senders
{
    my $self = shift;

    my $provider = $self->sender_provider;
    while (my $account = $provider->create) {
        my $sender = XMPP::Bomber::Sender->new(
            hostname => $self->hostname,
            port     => $self->port,
            domain   => $self->domain,
            content_provider => $self->content_provider,
            receivers        => $self->receivers,
            account => $account,
        );
        $sender->start;

        AnyEvent->child(
            pid => $sender->pid,
            cb  => sub { $self->condvar->send($self) }
        );
        push @{$self->senders}, $sender;
        
    }
}

sub stop_senders
{
    my $self = shift;
    my $sender_count = 1;
    foreach my $sender ( @{ $self->senders } ) {
        $sender->stop;
    }
}

sub make_par
{
    my (%args) = @_;

    my $find_cmd = sub {
        my ($name, $default) = @_;

        my $cmd = $default;
        if (! $cmd) {
            foreach my $path (split(/:/, $ENV{PATH})) {
                my $fqpath = File::Spec->catfile($path, $name);
                if (-x $fqpath) {
                    $cmd = $fqpath;
                    last;
                }
            }
        }

        if (! $cmd || ! -x $cmd) {
            die "Could not find a suitable '$name' executable";
        }
        return $cmd;
    };

    my $pp = $find_cmd->('pp', $ENV{PAR_PACKER});
    my $xmpp_bomber = $find_cmd->('xmpp-bomber', $ENV{XMPP_BOMBER});

    # Now pack all this stuff
    my @modules = (
        'DateTime::Locale::en', # need to add this manually
        'XMPP::Bomber',
        'XMPP::Bomber::Sender',
        'XMPP::Bomber::Receiver',
        'XMPP::Bomber::Account',
        'XMPP::Bomber::Role::ContentProvider',
        'XMPP::Bomber::Role::UserProvider',
        'XMPP::Bomber::UserProvider::Static',
        'XMPP::Bomber::UserProvider::OpenFire::Random',
        'XMPP::Bomber::ContentProvider::Gibberish',
        @{ $args{extra_modules} || [] }
    );

    my $outfile = $args{outfile} || 'xmpp-bomber.par';
    my @cmd = (
        $pp,
        '-I' => 'lib',
        "-o" => $outfile,
        (map { ("-M" => $_) } @modules ),
        $xmpp_bomber
    );
    system(@cmd);
    if ($? != 0 || ! -e $outfile) {
        die "Failed to execute @cmd";
    }
}

1;

__END__

=head1 NAME

XMPP::Bomber - Stretch The Limit Of Your XMPP Servers

=head1 SYNOPSIS

  use XMPP::Bomber;

  my $hostname = ...;
  my $password = ...;

  # First, create the "senders" you want to use
  # In this case we only want one sender, and the sender is a static one
  my $senders = XMPP::Bomber::Default::StaticUserProvider->new(
    users => [
      XMPP::Bomber::Account->new(
        username => $opts{username},
        password => $opts{password},
        domain   => $opts{domain},
      )
    ]
  );

  # Now, define the "receivers".
  # We will be generating 100 users with random usernames directly into the
  # OpenFire database
  my $receivers = XMPP::Bomber::OpenFire::RandomUserProvider->new(
    domain       => $opts{domain},
    count        => 100,
    connect_info => [ 
      $opts{dsn},
      $opts{dbuser},
      $opts{dbpass},
      { RaiseError => 1, AutoCommit => 1 }
    ],
  );

  # Define the content provider
  my $content = XMPP::Bomber::Default::GibberishContentProvider->new(
    max_length => 512,
  );

  my $bomber = XMPP::Bomber->new(
    hostname          => '192.168.0.5',
    domain            => 'endeworks.jp',
    sender_provider   => $senders,
    receiver_provider => $receivers,
    content_provider  => $content
  );

  $bomber->run;

=head1 DESCRIPTION

This module exists solely to test the amount of messages that your XMPP
server can handle. It creates one or more "senders", and one or more
"receivers". There's also a 

You can specify how these se

=head1 


=cut