Sphinx::Manager - Sphinx search engine management (start/stop)

    use Sphinx::Manager;

    my $mgr = Sphinx::Manager->new({ config_file => '/etc/sphinx.conf' });
    $mgr->start_searchd;
    $mgr->restart_searchd;
    $mgr->reload_searchd;
    $mgr->stop_searchd;
    $mgr->get_searchd_pid;
    $mgr->run_indexer;

    $mgr = Sphinx::Manager->new(\%opts);

    $mgr->config_file($filename)
    $filename = $mgr->config_file;

    $mgr->pid_file($filename)
    $filename = $mgr->pid_file;

    $mgr->bindir($dir)
    $dir = $mgr->bindir;

    $mgr->debug(1);
    $mgr->debug(0);
    $debug_state = $mgr->debug;

    $mgr->process_timeout($secs)
    $secs = $mgr->process_timeout;

    $mgr->searchd_args(\@args)
    $args = $mgr->searchd_args;

    $mgr->indexer_args(\@args)
    $args = $mgr->indexer_args;

    $mgr->start_searchd;
    $mgr->start_searchd($ok_if_running);

    $mgr->stop_searchd;

    $mgr->restart_searchd;

    $mgr->reload_searchd;

    $pids = $mgr->get_searchd_pid;

    perldoc Sphinx::Manager

package Sphinx::Manager;

use warnings;
use strict;
use base qw/Class::Accessor::Fast/;

use Carp qw/croak/;
use Proc::ProcessTable;
use Path::Class;
use File::Spec;
use Sphinx::Config;
use Errno qw/ECHILD/;

our $VERSION = '0.06';

__PACKAGE__->mk_accessors(qw/config_file 
			  pid_file 
			  bindir 
			  searchd_args 
                          searchd_sudo
			  indexer_args 
                          indexer_sudo
			  process_timeout 
			  debug/);

my $default_config_file = 'sphinx.conf';
my $default_process_timeout = 10;

sub new {
    my $class = shift;
    my $self = $class->SUPER::new(@_);

    $self->debug(0) unless $self->debug;
    $self->config_file($default_config_file) unless $self->config_file;
    $self->process_timeout($default_process_timeout) unless $self->process_timeout;
    
    return $self;
}

# Determines pid_file from explicitly given file or by reading the config
sub _find_pidfile {
    my $self = shift;

    my $config_file = $self->config_file || $default_config_file;

    if (my $file = $self->pid_file) {
	return $self->{_pid_file} = Path::Class::file($file);
    }
    if ($self->{_config_file} && $config_file eq $self->{_config_file}) {
	# Config file unchanged
	return $self->{_pid_file} if $self->{_pid_file};
    }
    $self->_load_config_file;
    return $self->{_pid_file};
}

# Loads given config file and extracts the pid_file
sub _load_config_file {
    my $self = shift;

    my $config_file = $self->config_file || $default_config_file;

    my $config = Sphinx::Config->new;
    $config->parse($config_file);
    if (my $pid_file = $config->get('searchd', undef, 'pid_file')) {
	$self->{_pid_file} = Path::Class::file($pid_file);
    }
    $self->{_config_file} = Path::Class::file($config_file); # records which file we have loaded
}

# Find executable file
sub _find_exe {
    my $self = shift;
    my $name = shift;

    return Path::Class::file($self->bindir, $name) if $self->bindir;

    my @candidates = map { Path::Class::file($_, $name) } File::Spec->path();
    for my $bin (@candidates) {
	return $bin if -x "$bin";
    }
    die "Failed to find $name binary in bindir or system path; please specify bindir correctly";
}

# Find a process for given pid; return the PID if the process matches the given pattern
# If pid is not given, returns all process IDs matching the pattern
sub _findproc {
    my ($self, $pid, $pat) = @_;

    my $t = Proc::ProcessTable->new;

    if ($pid) {
	my $process;
	for (@{$t->table}) {
	    $process = $_, last if $_->pid == $pid;
	}
	return [ $pid ] if $process;
    }
    else {
	my @procs;
	for (@{$t->table}) {
	    my $cmndline = $_->{cmndline} || $_->{fname};
	    warn "Checking $cmndline against $pat" if $self->debug > 2;
	    push(@procs, $_->pid) if $cmndline =~ /$pat/;
	}
	return \@procs;
    }

    return [];
}

# Waits for a PID to disappear from the process table; returns 1 if found, 0 if timeout.
sub _wait_for_death {
    my $self = shift;
    my $pid = shift;
    my $timeout = $self->process_timeout || $default_process_timeout;

    my $ret = 0;
    my $t = time() + $timeout;
    while (time() < $t) {
	$ret++, last unless @{$self->_findproc($pid)};
	sleep(1);
    }
    return $ret;
}

# Waits for a process matching a given pattern to appear in the process table; returns 1 if found, 0 if timeout.
sub _wait_for_proc {
    my $self = shift;
    my $pat = shift;
    my $timeout = $self->process_timeout || $default_process_timeout;

    my $ret = 0;
    my $t = time() + $timeout;
    while (time() < $t) {
	$ret++, last if @{$self->_findproc(undef, $pat)};
	sleep(1);
    }
    return $ret;
}

sub _system_with_status
{
    my (@args) = @_;

    local $SIG{CHLD} = 'IGNORE';
    my $status = system(@args);
    unless ($status == 0) {
        if ($? == -1) {
	    return '' if $! == ECHILD;
            return "@args failed to execute: $!";
        }
        if ($? & 127) {
            return sprintf("@args died with signal %d, %s coredump\n",
                           ($? & 127),  ($? & 128) ? 'with' : 'without');
        }
        return sprintf("@args exited with value %d\n", $? >> 8);
    }
    return '';
}

# Get regexp for matching command line
sub _get_searchd_matchre {
    my $self = shift;
    my $c = $self->{_config_file}->stringify;
    return qr/searchd.*(?:\s|=)$c(?:$|\s)/;
}

sub get_searchd_pid {
    my $self = shift;

    my $pids = [];
    my $pidfile = $self->_find_pidfile;
    if ( -f "$pidfile" ) {
	if (my $pid = $pidfile->slurp(chomp => 1)) {
	    push(@$pids, $pid) if @{$self->_findproc($pid, 'searchd')};
	}
    }
    if (! @$pids) {
	# backup plan if PID file is empty or invalid
	$pids = $self->_findproc(undef, $self->_get_searchd_matchre);
    }
    warn("Found searchd pid " . join(", ", @$pids)) if $self->debug;
    return $pids;
}

sub start_searchd {
    my $self = shift;
    my $ok_if_running = shift;

    my $pidfile = $self->_find_pidfile;
    warn "start_searchd: Checking pidfile $pidfile" if $self->debug;

    if ( -f "$pidfile" ) {
	my $pid = Path::Class::file($pidfile)->slurp(chomp => 1);
	warn "start_searchd: Found PID $pid" if $self->debug;
	if ($pid && @{$self->_findproc($pid, qr/searchd/)}) {
	    return if $ok_if_running;
	    die "searchd is already running, PID $pid";
	}
    }

    my @args;
    if (my $sudo = $self->searchd_sudo) {
	if (ref($sudo) ne 'ARRAY') {
	    $sudo = [ split(/\s+/, $sudo) ];
	}
	push(@args, @$sudo);
    }
    push(@args, $self->_find_exe('searchd'));
    push(@args, "--config", $self->{_config_file}->stringify);
    push(@args, @{$self->searchd_args}) if $self->searchd_args;
    warn("Executing " . join(" ", @args)) if $self->debug;

    local $SIG{CHLD} = 'IGNORE';
    my $pid = fork();
    die "Fork failed: $!" unless defined $pid;
    if ($pid == 0) {
	fork() and exit; # double fork to ensure detach
	exec(@args)
	    or die("Failed to exec @args}: $!");
    }

    die "Searchd not running after timeout" 
	unless $self->_wait_for_proc($self->_get_searchd_matchre);

}

sub _kill {
    my ($self, $sig, @pids) = @_;

    if (my $sudo = $self->searchd_sudo) {
	my @args;
	if (ref($sudo) ne 'ARRAY') {
	    $sudo = [ split(/\s+/, $sudo) ];
	}
	push(@args, @$sudo);
	push(@args, 'kill');
	push(@args, "-$sig", @pids);
	_system_with_status(@args);
    }
    else {
	kill $sig, @pids;
    }
}

sub stop_searchd {
    my $self = shift;

    my $pids = $self->get_searchd_pid;
    if (@$pids) {
	$self->_kill(15, @$pids);
	unless ($self->_wait_for_death(@$pids)) {
	    $self->_kill(9, @$pids);
	    unless ($self->_wait_for_death(@$pids)) {
		die "Failed to stop searchd PID " . join(", ", @$pids) . ", even with sure kill";
	    }
	}
    }
    # nothing found to kill so assume success
}

sub restart_searchd {
    my $self = shift;
    $self->stop_searchd;
    $self->start_searchd(1);
}

sub reload_searchd {
    my $self = shift;
    
    my $pids = $self->get_searchd_pid;
    if (@$pids) {
	# send HUP
	$self->_kill(1, @$pids);
    }
    else {
	$self->start_searchd(1);
    }
}

sub run_indexer {
    my $self = shift;
    my @extra_args = @_;

    my @args;
    if (my $sudo = $self->indexer_sudo) {
	if (ref($sudo) ne 'ARRAY') {
	    $sudo = [ split(/\s+/, $sudo) ];
	}
	push(@args, @$sudo);
    }
    push(@args, my $indexer = $self->_find_exe('indexer'));

    warn("Using indexer @args") if $self->debug;
    die "Cannot execute Sphinx indexer binary $indexer" unless -x "$indexer";

    my $config = $self->config_file || $default_config_file;
    push(@args, "--config", $config);
    push(@args, @{$self->indexer_args}) if $self->indexer_args;
    push(@args, @extra_args) if @extra_args;

    if (my $status = _system_with_status(@args)) {
	die $status;
    }
}

1;

__END__