File Coverage

blib/lib/Mojolicious/Plugin/Minion/Workers.pm

Criterion	Covered	Total	%
statement	3	61	4.9
branch	0	30	0.0
condition	0	28	0.0
subroutine	1	11	9.0
pod	2	7	28.5
total	6	137	4.3

package Mojolicious::Plugin::Minion::Workers;
use Mojo::Base 'Mojolicious::Plugin::Minion';

our $VERSION = '0.9093';# as to Minion version/10+

has minion => undef, weak=>1;
has qw(conf);

sub register {
  my ($self, $app, $conf) = @_;

  my $workers = delete $conf->{workers};
  my $manage = delete $conf->{manage};
  my $tasks = delete $conf->{tasks} || {};

  my $backend = (keys %$conf)[0]
    if keys %$conf == 1;

  $conf->{$backend} = $conf->{$backend}->($app)
    if $backend && ref($conf->{$backend}) eq 'CODE';

  $self->SUPER::register($app, $conf)
    unless $app->renderer->get_helper('minion') || !$backend;

  $self->minion($app->minion);
  $self->conf({
    %$conf,
    workers => $workers,
    is_manage => !$ARGV[0]
                    || $ARGV[0] eq 'daemon'
                    || $ARGV[0] eq 'prefork',
    is_prefork => $ENV{HYPNOTOAD_APP}
                    || ($ARGV[0] && $ARGV[0] eq 'prefork'),
  });

  $app->minion->attr('workers'=> sub { $self }, weak=>1);

  while (my ($name, $sub) = each %$tasks) {
    $app->log->debug(sprintf("Applied task [%s] in [%s] from config", $name, $app->minion->add_task($name => $sub)));
  }

  $self->manage()
    and $self->conf->{is_manage} = 0
    if $manage;

  return $self;
}

sub manage {
  my ($self, $workers) = @_;
  my $conf = $self->conf;
  return
    unless $conf->{is_manage};

  $workers ||= $conf->{workers}
    or return;

  my $minion = $self->minion;

  if ($conf->{is_prefork}) {
    $self->prefork;
  } else {
    $self->subprocess;
  }
  return $self;
}

# Cases: hypnotoad script/app.pl | perl script/app.pl prefork
sub prefork {
  my ($self) = @_;

  # case hot deploy and kill -USR2
  return
    #~ if $hypnotoad_pid && !$ENV{HYPNOTOAD_STOP};
    if $ENV{HYPNOTOAD_PID} && !$ENV{HYPNOTOAD_STOP};

  $self->kill_workers;

  return if $ENV{HYPNOTOAD_STOP};

  my $workers = $self->conf->{workers};
  while ($workers--) {
    defined(my $pid = fork())
      || die "Can't fork: $!";
    next  if $pid;
    daemonize();
    $self->worker_run;
    CORE::exit(0);
  }
}

# Cases: morbo script/app.pl | perl script/app.pl daemon
sub subprocess {
  my ($self) = @_;

  $self->kill_workers;

  # subprocess allow run/restart worker later inside app worker
  my $subprocess = Mojo::IOLoop::Subprocess->new();
  $subprocess->run(
    sub {
      my $subprocess = shift;
      $self->worker_run;
      return $$;
    },
    sub {1}
  );
  # Dont $subprocess->ioloop->start here!
}

sub worker_run {
  my ($self) = @_;
  my $minion = $self->minion;
  $ENV{MINION_PID} = $$;
  $0 = "$0 minion worker";
  $minion->app->log->info("Minion worker (pid $$) was starting");
  $minion->worker->run;
}



sub kill_workers {
  my ($self, $workers) = @_;
  my $minion = $self->minion;
  $workers ||= $minion->backend->list_workers(0,1000)->{workers};

  kill 'QUIT', $_->{pid}
    and $minion->app->log->info("Minion worker (pid $_->{pid}) was stopped")
    for @$workers;
}

 sub daemonize {
  #~ chdir("/")                  || die "can't chdir to /: $!";
  #~ defined(my $pid = fork())   || die "can't fork: $!";
  #~ return 0
    #~ if $pid; # parent

  require POSIX;
  (POSIX::setsid() != -1)               || die "Can't start a new session: $!";
  open(STDIN,  "< /dev/null")    || die "Can't read /dev/null: $!";
  open(STDOUT, "> /dev/null") || die "Can't write to /dev/null: $!";
  open(STDERR, ">&STDOUT")  || die "Can't dup stdout: $!";

   #~ return $$;
 }

1;

__END__