File Coverage

blib/lib/BusyBird/Main.pm

Criterion	Covered	Total	%
statement	87	92	94.5
branch	23	26	88.4
condition	6	6	100.0
subroutine	22	22	100.0
pod	11	11	100.0
total	149	157	94.9

package BusyBird::Main;
use v5.8.0;
use strict;
use warnings;
use BusyBird::Timeline;
use BusyBird::Watcher::Aggregator;
use BusyBird::Log qw(bblog);
use BusyBird::Config;
use Tie::IxHash;
use Carp;
use Try::Tiny;

our @CARP_NOT = qw(BusyBird::Timeline BusyBird::Config);

sub new {
    my ($class) = @_;
    tie(my %timelines, 'Tie::IxHash');
    my $self = bless {
        timelines => \%timelines,
        config => BusyBird::Config->new(type => "global", with_default => 1),
    }, $class;
    return $self;
}

sub timeline {
    my ($self, $name) = @_;
    my $timeline = $self->get_timeline($name);
    if(not defined $timeline) {
        $timeline = $self->create_timeline($name);
        $self->install_timeline($timeline);
    }
    return $timeline;
}

sub create_timeline {
    my ($self, $name) = @_;
    return BusyBird::Timeline->new(name => $name, storage => $self->get_config("default_status_storage"));
}

sub get_timeline {
    my ($self, $name) = @_;
    return $self->{timelines}{$name};
}

sub get_all_timelines {
    my ($self) = @_;
    return values %{$self->{timelines}};
}

sub install_timeline {
    my ($self, $timeline) = @_;
    if($timeline->name eq "") {
        bblog("warn", "Invalid timeline name (it's empty)");
        return;
    }
    if($timeline->name =~ qr{/}) {
        bblog("warn", "Invalid timeline name (it contains /)");
        return;
    }
    $self->{timelines}{$timeline->name} = $timeline;
}

sub uninstall_timeline {
    my ($self, $name) = @_;
    my $timeline = $self->get_timeline($name);
    delete $self->{timelines}{$name};
    return $timeline;
}

sub set_config {
    shift()->{config}->set_config(@_);
}

sub get_config {
    shift()->{config}->get_config(@_);
}

sub get_timeline_config {
    my ($self, $timeline_name, $key) = @_;
    my $timeline = $self->get_timeline($timeline_name);
    my $timeline_config = defined($timeline) ? $timeline->get_config($key) : undef;
    return $timeline_config if defined $timeline_config;
    return $self->get_config($key);
}

sub watch_unacked_counts {
    my ($self, %watch_args) = @_;
    my $level = $watch_args{level};
    $level = 'total' if not defined $level;
    my $assumed = $watch_args{assumed};
    my $callback = $watch_args{callback};
    if(!defined($assumed) || ref($assumed) ne 'HASH') {
        croak 'assumed must be a hash-ref';
    }
    if(!defined($callback) || ref($callback) ne 'CODE') {
        croak "callback must be a code-ref";
    }
    my $watcher = BusyBird::Watcher::Aggregator->new;
    foreach my $tl_name (keys %$assumed) {
        my $timeline = $self->get_timeline($tl_name);
        next if not defined $timeline;
        my $tl_watcher = $timeline->watch_unacked_counts(
            assumed => {$level => $assumed->{$tl_name}},
            callback => sub {
                my ($error, $w, $unacked_counts) = @_;
                if(defined $error) {
                    $watcher->cancel();
                    $callback->("Error from timeline $tl_name: $error", $watcher);
                }else {
                    $callback->(undef, $watcher, { $tl_name => $unacked_counts });
                }
            }
        );
        if(!$tl_watcher->isa('Async::Selector::Aggregator')) {
            confess '$tl_watcher is not a Async::Selector::Aggregator. Something is terribly wrong.';
        }
        $watcher->add($tl_watcher);
        last if !$watcher->active;
    }
    if(!$watcher->watchers) {
        croak "assumed argument does not contain any installed timeline.";
    }
    return $watcher;
}


1;

__END__