<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;"># -*- cperl -*-
# Copyright (c) 2007, 2015 Oracle and/or its affiliates. All rights reserved.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; version 2
# of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

package My::SafeProcess;

#
# Class that encapsulates process creation, monitoring and cleanup
#
# Spawns a monitor process which spawns a new process locally or
# remote using subclasses My::Process::Local or My::Process::Remote etc.
#
# The monitor process runs a simple event loop more or less just
# waiting for a reason to zap the process it monitors. Thus the user
# of this class does not need to care about process cleanup, it's
# handled automatically.
#
# The monitor process wait for:
#  - the parent process to close the pipe, in that case it
#    will zap the "monitored process" and exit
#  - the "monitored process" to exit, in which case it will exit
#    itself with same exit code as the "monitored process"
#  - the parent process to send the "shutdown" signal in wich case
#    monitor will kill the "monitored process" hard and exit
#
#
# When used it will look something like this:
# $&gt; ps
#  [script.pl]
#   - [monitor for `mysqld`]
#     - [mysqld]
#   - [monitor for `mysqld`]
#     - [mysqld]
#   - [monitor for `mysqld`]
#     - [mysqld]
#
#

use strict;
use Carp;
use POSIX qw(WNOHANG);

use My::SafeProcess::Base;
use base 'My::SafeProcess::Base';

use My::Find;
use My::Platform;

my %running;
my $_verbose= 0;
my $start_exit= 0;

END {
  # Kill any children still running
  for my $proc (values %running){
    if ( $proc-&gt;is_child($$) and ! $start_exit){
      #print "Killing: $proc\n";
      if ($proc-&gt;wait_one(0)){
	$proc-&gt;kill();
      }
    }
  }
}


sub is_child {
  my ($self, $parent_pid)= @_;
  croak "usage: \$safe_proc-&gt;is_child()" unless (@_ == 2 and ref $self);
  return ($self-&gt;{PARENT} == $parent_pid);
}


my @safe_process_cmd;
my $safe_kill;
my $bindir;
if(defined $ENV{MTR_BINDIR})
{
  # This is an out-of-source build. Build directory
  # is given in MTR_BINDIR env.variable
  $bindir = $ENV{MTR_BINDIR}."/mysql-test";
}
else
{
  $bindir = ".";
}


# Find the safe process binary or script
sub find_bin {
  if (IS_WIN32PERL or IS_CYGWIN)
  {
    # Use my_safe_process.exe
    my $exe= my_find_bin($bindir, ["lib/My/SafeProcess", "My/SafeProcess"],
			 "my_safe_process");
    push(@safe_process_cmd, $exe);

    # Use my_safe_kill.exe
    $safe_kill= my_find_bin($bindir, "lib/My/SafeProcess", "my_safe_kill");
  }
  else
  {
    # Use my_safe_process
    my $exe= my_find_bin($bindir, ["lib/My/SafeProcess", "My/SafeProcess"],
			 "my_safe_process");
    push(@safe_process_cmd, $exe);
  }
}


sub new {
  my $class= shift;

  my %opts=
    (
     verbose     =&gt; 0,
     @_
    );

  my $path     = delete($opts{'path'})    or croak "path required @_";
  my $args     = delete($opts{'args'})    or croak "args required @_";
  my $input    = delete($opts{'input'});
  my $output   = delete($opts{'output'});
  my $error    = delete($opts{'error'});
  my $verbose  = delete($opts{'verbose'});
  my $nocore   = delete($opts{'nocore'});
  my $host     = delete($opts{'host'});
  my $shutdown = delete($opts{'shutdown'});
  my $user_data= delete($opts{'user_data'});
  my $envs     = delete($opts{'envs'});
  my $daemon_mode = delete($opts{'daemon_mode'});
  my $pid_file= delete($opts{'pid_file'})
                  if defined $daemon_mode &amp;&amp; $daemon_mode == 1;

#  if (defined $host) {
#    $safe_script=  "lib/My/SafeProcess/safe_process_cpcd.pl";
#  }

  if (IS_CYGWIN){
    $path= mixed_path($path);
    $input= mixed_path($input);
    $output= mixed_path($output);
    $error= mixed_path($error);
  }

  my @safe_args;
  my ($safe_path, $safe_script)= @safe_process_cmd;
  push(@safe_args, $safe_script) if defined $safe_script;

  push(@safe_args, "--verbose") if $verbose &gt; 0;
  push(@safe_args, "--nocore") if $nocore;

  # Point the safe_process at the right parent if running on cygwin
  push(@safe_args, "--parent-pid=".Cygwin::pid_to_winpid($$)) if IS_CYGWIN;

  foreach my $env_var (@$envs) {
    croak("Missing = in env string") unless $env_var =~ /=/;
    croak("Env string $env_var seen, probably missing value for --mysqld-env")
      if $env_var =~ /^--/;
    push @safe_args, "--env $env_var";
  }

  push(@safe_args, "--");
  push(@safe_args, $path); # The program safe_process should execute

  if ($start_exit) {	 # Bypass safe_process instead, start program directly
    @safe_args= ();
    $safe_path= $path;
  }
  push(@safe_args, @$$args);

  print "### safe_path: ", $safe_path, " ", join(" ", @safe_args), "\n"
    if $verbose &gt; 1;

  my $pid= create_process(
			  path      =&gt; $safe_path,
			  input     =&gt; $input,
			  output    =&gt; $output,
			  error     =&gt; $error,
                          append    =&gt; $opts{append},
			  args      =&gt; \@safe_args,
                          pid_file  =&gt; $pid_file

			 );

  my $name     = delete($opts{'name'}) || "SafeProcess$pid";
  my $proc= bless
    ({
      SAFE_PID  =&gt; $pid,
      SAFE_WINPID  =&gt; $pid, # Inidicates this is always a real process
      SAFE_NAME =&gt; $name,
      SAFE_SHUTDOWN =&gt; $shutdown,
      PARENT =&gt; $$,
      SAFE_USER_DATA =&gt; $user_data,
     }, $class);

  # Put the new process in list of running
  $running{$pid}= $proc;
  return $proc;

}


sub run {
  my $proc= new(@_);
  $proc-&gt;wait_one();
  return $proc-&gt;exit_status();
}

#
# Shutdown process nicely, and wait for shutdown_timeout seconds
# If processes hasn't shutdown, kill them hard and wait for return
#
sub shutdown {
  my $shutdown_timeout= shift;
  my @processes= @_;
  _verbose("shutdown, timeout: $shutdown_timeout, @processes");

  return if (@processes == 0);

  # Call shutdown function if process has one, else
  # use kill
  foreach my $proc (@processes){
    _verbose("  proc: $proc");
    my $shutdown= $proc-&gt;{SAFE_SHUTDOWN};
    if ($shutdown_timeout &gt; 0 and defined $shutdown){
      $shutdown-&gt;();
      $proc-&gt;{WAS_SHUTDOWN}= 1;
    }
    else {
      $proc-&gt;start_kill();
    }
  }

  my @kill_processes= ();

  # Wait max shutdown_timeout seconds for those process
  # that has been shutdown
  foreach my $proc (@processes){
    next unless $proc-&gt;{WAS_SHUTDOWN};
    my $ret= $proc-&gt;wait_one($shutdown_timeout);
    if ($ret != 0) {
      push(@kill_processes, $proc);
    }
    # Only wait for the first process with shutdown timeout
    $shutdown_timeout= 0;
  }

  # Wait infinitely for those process
  # that has been killed
  foreach my $proc (@processes){
    next if $proc-&gt;{WAS_SHUTDOWN};
    my $ret= $proc-&gt;wait_one(undef);
    if ($ret != 0) {
      warn "Wait for killed process failed!";
      push(@kill_processes, $proc);
      # Try one more time, best option...
    }
  }

  # Return if all servers has exited
  return if (@kill_processes == 0);

  foreach my $proc (@kill_processes){
    $proc-&gt;start_kill();
  }

  foreach my $proc (@kill_processes){
    $proc-&gt;wait_one(undef);
  }

  return;
}


sub _winpid ($) {
  my ($pid)= @_;

  # In win32 perl, the pid is already the winpid
  return $pid unless IS_CYGWIN;

  # In cygwin, the pid is the pseudo process -&gt;
  # get the real winpid of my_safe_process
  return Cygwin::pid_to_winpid($pid);
}


#
# Tell the process to die as fast as possible
#
sub start_kill {
  my ($self)= @_;
  croak "usage: \$safe_proc-&gt;start_kill()" unless (@_ == 1 and ref $self);
  _verbose("start_kill: $self");
  my $ret= 1;

  my $pid= $self-&gt;{SAFE_PID};
  die "INTERNAL ERROR: no pid" unless defined $pid;

  if (IS_WINDOWS and defined $self-&gt;{SAFE_WINPID})
  {
    die "INTERNAL ERROR: no safe_kill" unless defined $safe_kill;

    my $winpid= _winpid($pid);
    $ret= system($safe_kill, $winpid) &gt;&gt; 8;

    if ($ret == 3){
      print "Couldn't open the winpid: $winpid ".
	"for pid: $pid, try one more time\n";
      sleep(1);
      $winpid= _winpid($pid);
      $ret= system($safe_kill, $winpid) &gt;&gt; 8;
      print "Couldn't open the winpid: $winpid ".
	"for pid: $pid, continue and see what happens...\n";
    }
  }
  else
  {
    $pid= $self-&gt;{SAFE_PID};
    die "Can't kill not started process" unless defined $pid;
    $ret= kill("TERM", $pid);
  }

  return $ret;
}


sub dump_core {
  my ($self)= @_;
  return if IS_WINDOWS;
  my $pid= $self-&gt;{SAFE_PID};
  die "Can't cet core from not started process" unless defined $pid;
  _verbose("Sending ABRT to $self");
  kill ("ABRT", $pid);
  return 1;
}


#
# Kill the process as fast as possible
# and wait for it to return
#
sub kill {
  my ($self)= @_;
  croak "usage: \$safe_proc-&gt;kill()" unless (@_ == 1 and ref $self);

  $self-&gt;start_kill();
  $self-&gt;wait_one();
  return 1;
}


sub _collect {
  my ($self)= @_;

  $self-&gt;{EXIT_STATUS}= $?;
  _verbose("_collect: $self");

  # Take the process out of running list
  my $pid= $self-&gt;{SAFE_PID};
  die unless delete($running{$pid});
}


# Wait for process to exit
# optionally with a timeout
#
# timeout
#   undef -&gt; wait blocking infinitely
#   0     -&gt; just poll with WNOHANG
#   &gt;0    -&gt; wait blocking for max timeout seconds
#
# RETURN VALUES
#  0 Not running
#  1 Still running
#
sub wait_one {
  my ($self, $timeout)= @_;
  croak "usage: \$safe_proc-&gt;wait_one([timeout])" unless ref $self;

  _verbose("wait_one $self, $timeout");

  if ( ! defined($self-&gt;{SAFE_PID}) ) {
    # No pid =&gt; not running
    _verbose("No pid =&gt; not running");
    return 0;
  }

  if ( defined $self-&gt;{EXIT_STATUS} ) {
    # Exit status already set =&gt; not running
    _verbose("Exit status already set =&gt; not running");
    return 0;
  }

  my $pid= $self-&gt;{SAFE_PID};

  my $use_alarm;
  my $blocking;
  if (defined $timeout)
  {
    if ($timeout == 0)
    {
      # 0 -&gt; just poll with WNOHANG
      $blocking= 0;
      $use_alarm= 0;
    }
    else
    {
      # &gt;0 -&gt; wait blocking for max timeout seconds
      $blocking= 1;
      $use_alarm= 1;
    }
  }
  else
  {
    # undef -&gt; wait blocking infinitely
    $blocking= 1;
    $use_alarm= 0;
  }
  #_verbose("blocking: $blocking, use_alarm: $use_alarm");

  my $retpid;
  eval
  {
    # alarm should break the wait
    local $SIG{ALRM}= sub { die "waitpid timeout"; };

    alarm($timeout) if $use_alarm;

    $retpid= waitpid($pid, $blocking ? 0 : &amp;WNOHANG);

    alarm(0) if $use_alarm;
  };

  if ($@)
  {
    die "Got unexpected: $@" if ($@ !~ /waitpid timeout/);
    if (!defined $retpid) {
      # Got timeout
      _verbose("Got timeout");
      return 1;
    }
    # Got pid _and_ alarm, continue
    _verbose("Got pid and alarm, continue");
  }

  if ( $retpid == 0 ) {
    # 0 =&gt; still running
    _verbose("0 =&gt; still running");
    return 1;
  }

  if ( not $blocking and $retpid == -1 ) {
    # still running
    _verbose("still running");
    return 1;
  }

  #warn "wait_one: expected pid $pid but got $retpid"
  #  unless( $retpid == $pid );

  $self-&gt;_collect();
  return 0;
}


#
# Wait for any process to exit
#
# Returns a reference to the SafeProcess that
# exited or undefined
#
sub wait_any {
  my $ret_pid;
  if (IS_WIN32PERL) {
    # Can't wait for -1 =&gt; use a polling loop
    do {
      Win32::Sleep(10); # 10 milli seconds
      foreach my $pid (keys %running){
	$ret_pid= waitpid($pid, &amp;WNOHANG);
	last if $pid == $ret_pid;
      }
    } while ($ret_pid == 0);
  }
  else
  {
    $ret_pid= waitpid(-1, 0);
    if ($ret_pid &lt;= 0){
      # No more processes to wait for
      print STDERR "wait_any, got invalid pid: $ret_pid\n";
      return undef;
    }
  }

  # Look it up in "running" table
  my $proc= $running{$ret_pid};
  unless (defined $proc){
    print STDERR "Could not find pid: $ret_pid in running list\n";
    print STDERR "running: ". join(", ", keys(%running)). "\n";
    return undef;
  }
  $proc-&gt;_collect;
  return $proc;
}


#
# Wait for any process to exit, or a timeout
#
# Returns a reference to the SafeProcess that
# exited or a pseudo-process with $proc-&gt;{timeout} == 1
#

sub wait_any_timeout {
  my $class= shift;
  my $timeout= shift;
  my $proc;
  my $millis=10;

  do {
    ::mtr_milli_sleep($millis);
    # Slowly increse interval up to max. 1 second
    $millis++ if $millis &lt; 1000;
    # Return a "fake" process for timeout
    if (::has_expired($timeout)) {
      $proc= bless
	({
	  SAFE_PID  =&gt; 0,
	  SAFE_NAME =&gt; "timer",
	  timeout =&gt; 1,
	 }, $class);
    } else {
      $proc= check_any();
    }
  } while (! $proc);

  return $proc;
}


#
# Wait for all processes to exit
#
sub wait_all {
  while(keys %running)
  {
    wait_any();
  }
}

#
# Set global flag to tell all safe_process to exit after starting child
#

sub start_exit {
  $start_exit= 1;
}

#
# Check if any process has exited, but don't wait.
#
# Returns a reference to the SafeProcess that
# exited or undefined
#
sub check_any {
  for my $proc (values %running){
    if ( $proc-&gt;is_child($$) ) {
      if (not $proc-&gt;wait_one(0)) {
	_verbose ("Found exited $proc");
	return $proc;
      }
    }
  }
  return undef;
}


# Overload string operator
# and fallback to default functions if no
# overloaded function is found
#
use overload
  '""' =&gt; \&amp;self2str,
  fallback =&gt; 1;


#
# Return the process as a nicely formatted string
#
sub self2str {
  my ($self)= @_;
  my $pid=  $self-&gt;{SAFE_PID};
  my $winpid=  $self-&gt;{SAFE_WINPID};
  my $name= $self-&gt;{SAFE_NAME};
  my $exit_status= $self-&gt;{EXIT_STATUS};

  my $str= "[$name - pid: $pid";
  $str.= ", winpid: $winpid"      if defined $winpid;
  $str.= ", exit: $exit_status"   if defined $exit_status;
  $str.= "]";
}

sub _verbose {
  return unless $_verbose;
  print STDERR " ## ". @_. "\n";
}


sub pid {
  my ($self)= @_;
  return $self-&gt;{SAFE_PID};
}

sub user_data {
  my ($self)= @_;
  return $self-&gt;{SAFE_USER_DATA};
}


1;
</pre></body></html>