File Coverage

blib/lib/Mojo/IOLoop/Signal.pm

Criterion	Covered	Total	%
statement	18	78	23.0
branch	0	26	0.0
condition	0	8	0.0
subroutine	6	19	31.5
pod	5	6	83.3
total	29	137	21.1

package Mojo::IOLoop::Signal;
use Mojo::Base 'Mojo::EventEmitter';

use Config;
use IO::Handle;
use Mojo::IOLoop;
use Mojo::IOLoop::Stream;
use Scalar::Util 'weaken';

our $VERSION = '0.001';
my %SIGNAME = map { $_ => 1 } split /\s+/, $Config{sig_name};
our %EXCLUDE = map { $_ => 1 } qw(PIPE KILL);

sub _instance {
    state $SELF = __PACKAGE__->_new;
    ref $_[0] ? $_[0] : $SELF
}

sub singleton { _instance(shift) }

sub new { die "Cannot construct Mojo::IOLoop::Signal objects. It's a singleton.\n" }

sub _new {
    my $class = shift;
    my $reactor =  Mojo::IOLoop->singleton->reactor;
    my $is_ev;
    if ($reactor->isa('Mojo::Reactor::EV')) {
        $is_ev = 1;
    } elsif ($reactor->isa('Mojo::Reactor::Poll')) {
        $is_ev = 0;
    } else {
        die "Unsupported reactor: " . ref($reactor);
    }
    bless { keep => {}, is_ev => $is_ev }, $class;
}

sub DESTROY {
    my $self = shift;
    $self->stop;
}

sub stop {
    my $self = _instance(shift);
    if (!$self->{is_ev}) {
        if ($self->{write}) {
            $self->{write}->close;
            $self->{read}->stop;
            $self->{read}->close_gracefully;
            delete $self->{$_} for qw(write read);
        }
        for my $name (keys %{$self->{keep}}) {
            $SIG{$name} = $self->{keep}{$name};
        }
    }
    $self->{keep} = {};
    $self;
}

sub _is_signame {
    my ($class, $name) = @_;
    $SIGNAME{$name} and !$EXCLUDE{$name};
}

sub once {
    my ($self, $name, $cb) = (_instance(shift), @_);
    $self->SUPER::once($name, $cb);
}

sub on {
    my ($self, $name, $cb) = (_instance(shift), @_);
    if ($self->_is_signame($name) and !exists $self->{keep}{$name}) {
        if ($self->{is_ev}) {
            $self->{keep}{$name} = EV::signal($name => sub { $self->emit($name, $name) });
        } else {
            if (!$self->{write}) {
                pipe my $read, my $write;
                $write->autoflush(1);
                $self->{read} = Mojo::IOLoop::Stream->new($read),
                $self->{read}->timeout(0);
                $self->{write} = $write;
                weaken $self;
                $self->{read}->on(read => sub {
                    my (undef, $bytes) = @_;
                    $self->emit($_, $_) for split /\n/, $bytes;
                });
                $self->{read}->start;
            }
            $self->{keep}{$name} = $SIG{$name} || 'DEFAULT';
            $SIG{$name} = sub {
                Mojo::IOLoop->timer(0 => sub {
                    syswrite $self->{write}, "$name\n" or warn "pipe write: $!";
                });
            };
        }
    }
    $self->SUPER::on($name, $cb);
}

sub unsubscribe {
    my ($self, $name, @arg) = (_instance(shift), @_);
    $self->SUPER::unsubscribe($name, @arg);
    if ($self->_is_signame($name) and !$self->has_subscribers($name)) {
        if ($self->{is_ev}) {
            delete $self->{keep}{$name};
        } else {
            $SIG{$name} = delete $self->{keep}{$name};
        }
    }
    if (!%{$self->{keep}}) {
        $self->stop;
    }
    $self;
}

1;
__END__