File Coverage

blib/lib/Ubic/Service/Hypnotoad.pm

Criterion	Covered	Total	%
statement	43	95	45.2
branch	7	42	16.6
condition	9	22	40.9
subroutine	10	17	58.8
pod	5	6	83.3
total	74	182	40.6

package Ubic::Service::Hypnotoad;
# ABSTRACT: Ubic service module for Mojolicious Hypnotoad
$Ubic::Service::Hypnotoad::VERSION = '0.3005';
use strict;
use warnings;

use parent qw(Ubic::Service::Skeleton);

use Ubic::Result qw(result);
use File::Basename;
use Time::HiRes qw(time);
use Capture::Tiny qw(:all);
use File::Spec::Functions qw(catfile file_name_is_absolute);




sub new {
	my ($class, $opt) = @_;

	my $bin = ref $opt->{bin} eq 'ARRAY' ? $opt->{bin} : [grep {length} split /\s+/, ($opt->{'bin'} // 'hypnotoad')];
	@$bin	or die "missing 'bin' parameter in new";
	my $app = $opt->{'app'} // '';
	length $app	or die "missing 'app' parameter in new";
	file_name_is_absolute($app)		or die "The 'app' parameter must be an absolute path";
	my $pid_file = $opt->{'pid_file'} // catfile(dirname($app), 'hypnotoad.pid');
	file_name_is_absolute($pid_file)	or die "The 'pid_file' parameter must be an absolute path";
	length $pid_file	or die "missing 'pid_file' parameter in new";

	my %env = %{ $opt->{'env'} // {} };

	my $wait_status = _calc_wait_status($opt->{wait_status});

	return bless {
		bin => $bin,
		app => $app,
		env => \%env,
		pid_file => $pid_file,
		start_time => undef,
		stop_time => undef,
		cwd => $opt->{cwd},
		wait_status => $wait_status,
	}, $class;
}

sub _calc_wait_status {
	my $wait_status = shift;
	my $step   = $wait_status->{step} // 0.1;
	my $trials = $wait_status->{trials} // 10;

	my $time_to_wait = $step * ($trials - 1) * $trials / 2 + 1;

	return {
		step   => $step,
		trials => $trials,
		time_to_wait => $time_to_wait,
	};
}

sub _read_pid {
	my $self = shift;

	return eval {
		open my $fh, "<", $self->{'pid_file'}	or die;
		my $pid = (scalar(<$fh>) =~ /(\d+)/g)[0];
		close $fh;
		$pid;
	};
}

sub status_impl {
	my $self = shift;

	my $pid = $self->_read_pid;

	if ($self->{'start_time'} and $self->{'start_time'} + $self->{wait_status}{time_to_wait} > time) {
		return result('broken')		if ! $pid;
	}
	$self->{'start_time'} = undef;

	if (! $pid) {
		$self->{'stop_time'} = undef;
		return result('not running');
	}

	if ($self->{'stop_time'} and $self->{'stop_time'} + $self->{wait_status}{time_to_wait} > time) {
		return result('broken');
	}

	my ($i, $running, $old_pid) = (0);
	do {
		$i++;
		$old_pid = $pid;
		$running = kill 0, $old_pid;
		$pid = $self->_read_pid		or return result('not running');
	} until ($pid == $old_pid or $i > 5);

	$pid == $old_pid	or return result('broken');

	return $running ? result('running', 'pid '.$pid) : result('not running');
}

sub start_impl {
	my $self = shift;

	local %ENV = (%ENV, %{ $self->{'env'} });

	if (defined $self->{cwd}) {
		chdir $self->{cwd} or die "chdir to '$self->{cwd}' failed: $!";
	}

	system(@{$self->{'bin'}}, $self->{'app'});
	$self->{'start_time'} = time;
	$self->{'stop_time'} = undef;

	return result('starting');
}

sub stop_impl {
	my $self = shift;

	if (defined $self->{cwd}) {
		chdir $self->{cwd} or die "chdir to '$self->{cwd}' failed: $!";
	}

	local %ENV = (%ENV, %{ $self->{'env'} });
	my (undef, $stderr) = capture {
		system(@{$self->{'bin'}}, '-s', $self->{'app'});
	};
	print $stderr	if length $stderr;
	$self->{'stop_time'} = time;
	$self->{'start_time'} = undef;

	return result('stopping');
}

sub reload {
	my $self = shift;

	my $pid = $self->_read_pid	or return 'not running';
	my $ret = kill "USR2", $pid;
	return $ret ? 'reloaded' : 'not running';
}

sub timeout_options {
	my $self = shift;

	return {
		start => {
			step => $self->{wait_status}{step},
			trials => $self->{wait_status}{trials},
		},
		stop => {
			step => $self->{wait_status}{step},
			trials => $self->{wait_status}{trials},
		}
	};
}





1;

__END__