Post-merge fixes. (0ec1397d) · Commits · Software / OSDI20 Artifacts / mariadb

mysql-test/lib/mtr_process.pl

+769 −34

Original line number	Diff line number	Diff line
		@@ -25,7 +25,28 @@ sub sleep_until_file_created ($$$);
		sub mtr_kill_processes ($);
		sub mtr_ping_with_timeout($);
		sub mtr_ping_port ($);
		sub mtr_kill_process ($$$);

		# Private IM-related operations.

		sub mtr_im_kill_process ($$$);
		sub mtr_im_load_pids ($);
		sub mtr_im_terminate ($);
		sub mtr_im_check_alive ($);
		sub mtr_im_check_main_alive ($);
		sub mtr_im_check_angel_alive ($);
		sub mtr_im_check_mysqlds_alive ($);
		sub mtr_im_check_mysqld_alive ($$);
		sub mtr_im_cleanup ($);
		sub mtr_im_rm_file ($);
		sub mtr_im_errlog ($);
		sub mtr_im_kill ($);
		sub mtr_im_wait_for_connection ($$$);
		sub mtr_im_wait_for_mysqld($$$);

		# Public IM-related operations.

		sub mtr_im_start ($$);
		sub mtr_im_stop ($$);

		# static in C
		sub spawn_impl ($$$$$$$$);
		@@ -335,16 +356,27 @@ sub mtr_process_exit_status {
		# kill IM manager first, else it will restart the servers
		sub mtr_kill_leftovers () {

		mtr_debug("mtr_kill_leftovers(): started.");

		mtr_im_stop($::instance_manager, 'mtr_kill_leftovers');

		# Start shutdown of masters and slaves. Don't touch IM-managed mysqld
		# instances -- they should be stopped by mtr_im_stop().

		mtr_debug("Shutting down mysqld-instances...");

		my @kill_pids;
		my %admin_pids;
		my $pid;

		#Start shutdown of instance_managers, masters and slaves
		foreach my $srv ($::instance_manager,
		@{$::instance_manager->{'instances'}},
		@{$::master},@{$::slave})
		foreach my $srv (@{$::master}, @{$::slave})
		{
		$pid= mtr_mysqladmin_start($srv, "shutdown", 70);
		mtr_debug(" - mysqld " .
		"(pid: $srv->{pid}; " .
		"pid file: '$srv->{path_pid}'; " .
		"socket: '$srv->{path_sock}'; ".
		"port: $srv->{port})");

		my $pid= mtr_mysqladmin_start($srv, "shutdown", 70);

		# Save the pid of the mysqladmin process
		$admin_pids{$pid}= 1;
		@@ -358,10 +390,17 @@ sub mtr_kill_leftovers () {
		$srv->{'pid'}= 0; # Assume we are done with it
		}

		# Start shutdown of clusters
		# Start shutdown of clusters.

		mtr_debug("Shutting down cluster...");

		foreach my $cluster (@{$::clusters})
		{
		$pid= mtr_ndbmgm_start($cluster, "shutdown");
		mtr_debug(" - cluster " .
		"(pid: $cluster->{pid}; " .
		"pid file: '$cluster->{path_pid})");

		my $pid= mtr_ndbmgm_start($cluster, "shutdown");

		# Save the pid of the ndb_mgm process
		$admin_pids{$pid}= 1;
		@@ -376,13 +415,16 @@ sub mtr_kill_leftovers () {

		foreach my $ndbd (@{$cluster->{'ndbds'}})
		{
		mtr_debug(" - ndbd " .
		"(pid: $ndbd->{pid}; " .
		"pid file: '$ndbd->{path_pid})");

		push(@kill_pids,{
		pid => $ndbd->{'pid'},
		pidfile => $ndbd->{'path_pid'},
		});
		$ndbd->{'pid'}= 0; # Assume we are done with it
		}

		}

		# Wait for all the admin processes to complete
		@@ -411,6 +453,8 @@ sub mtr_kill_leftovers () {
		# FIXME $path_run_dir or something
		my $rundir= "$::opt_vardir/run";

		mtr_debug("Processing PID files in directory '$rundir'...");

		if ( -d $rundir )
		{
		opendir(RUNDIR, $rundir)
		@@ -424,8 +468,12 @@ sub mtr_kill_leftovers () {

		if ( -f $pidfile )
		{
		mtr_debug("Processing PID file: '$pidfile'...");

		my $pid= mtr_get_pid_from_file($pidfile);

		mtr_debug("Got pid: $pid from file '$pidfile'");

		# Race, could have been removed between I tested with -f
		# and the unlink() below, so I better check again with -f

		@@ -436,14 +484,24 @@ sub mtr_kill_leftovers () {

		if ( $::glob_cygwin_perl or kill(0, $pid) )
		{
		mtr_debug("There is process with pid $pid -- scheduling for kill.");
		push(@pids, $pid); # We know (cygwin guess) it exists
		}
		else
		{
		mtr_debug("There is no process with pid $pid -- skipping.");
		}
		}
		}
		closedir(RUNDIR);

		if ( @pids )
		{
		mtr_debug("Killing the following processes with PID files: " .
		join(' ', @pids) . "...");

		start_reap_all();

		if ( $::glob_cygwin_perl )
		{
		# We have no (easy) way of knowing the Cygwin controlling
		@@ -457,6 +515,7 @@ sub mtr_kill_leftovers () {
		my $retries= 10; # 10 seconds
		do
		{
		mtr_debug("Sending SIGKILL to pids: " . join(' ', @pids));
		kill(9, @pids);
		mtr_report("Sleep 1 second waiting for processes to die");
		sleep(1) # Wait one second
		@@ -467,12 +526,20 @@ sub mtr_kill_leftovers () {
		mtr_warning("can't kill process(es) " . join(" ", @pids));
		}
		}

		stop_reap_all();
		}
		}
		else
		{
		mtr_debug("Directory for PID files ($rundir) does not exist.");
		}

		# We may have failed everything, but we now check again if we have
		# the listen ports free to use, and if they are free, just go for it.

		mtr_debug("Checking known mysqld servers...");

		foreach my $srv ( @kill_pids )
		{
		if ( defined $srv->{'port'} and mtr_ping_port($srv->{'port'}) )
		@@ -480,6 +547,8 @@ sub mtr_kill_leftovers () {
		mtr_warning("can't kill old process holding port $srv->{'port'}");
		}
		}

		mtr_debug("mtr_kill_leftovers(): finished.");
		}


		@@ -736,6 +805,9 @@ sub mtr_ping_with_timeout($) {
		my $res= 1; # If we just fall through, we are done
		# in the sense that the servers don't
		# listen to their ports any longer

		mtr_debug("Waiting for mysqld servers to stop...");

		TIME:
		while ( $timeout-- )
		{
		@@ -763,7 +835,14 @@ sub mtr_ping_with_timeout($) {
		last; # If we got here, we are done
		}

		$timeout or mtr_report("At least one server is still listening to its port");
		if ($res)
		{
		mtr_debug("mtr_ping_with_timeout(): All mysqld instances are down.");
		}
		else
		{
		mtr_report("mtr_ping_with_timeout(): At least one server is alive.");
		}

		return $res;
		}
		@@ -946,6 +1025,9 @@ sub mtr_ping_port ($) {
		{
		mtr_error("can't create socket: $!");
		}

		mtr_debug("Pinging server (port: $port)...");

		if ( connect(SOCK, $paddr) )
		{
		close(SOCK); # FIXME check error?
		@@ -1016,34 +1098,12 @@ sub mtr_kill_processes ($) {
		{
		foreach my $sig (15, 9)
		{
		last if mtr_kill_process($pid, $sig, 10);
		last if mtr_im_kill_process([ $pid ], $sig, 10);
		}
		}
		}


		sub mtr_kill_process ($$$) {
		my $pid= shift;
		my $signal= shift;
		my $timeout= shift; # Seconds to wait for process
		my $max_loop= $timeout*10; # Sleeping 0.1 between each kill attempt

		for (my $cur_attempt= 1; $cur_attempt <= $max_loop; ++$cur_attempt)
		{
		mtr_debug("Sending $signal to $pid...");

		kill($signal, $pid);

		last unless kill (0, $pid) and $max_loop--;

		mtr_verbose("Sleep 0.1 second waiting for processes $pid to die");

		select(undef, undef, undef, 0.1);
		}

		return $max_loop;
		}

		##############################################################################
		#
		# When we exit, we kill off all children
		@@ -1073,4 +1133,679 @@ sub mtr_exit ($) {
		exit($code);
		}

		##############################################################################
		#
		# Instance Manager management routines.
		#
		##############################################################################

		sub mtr_im_kill_process ($$$) {
		my $pid_lst= shift;
		my $signal= shift;
		my $timeout= shift;
		my $total_attempts= $timeout * 10;

		my %pids;

		foreach my $pid (@{$pid_lst})
		{
		$pids{$pid}= 1;
		}

		for (my $cur_attempt= 1; $cur_attempt <= $total_attempts; ++$cur_attempt)
		{
		foreach my $pid (keys %pids)
		{
		mtr_debug("Sending $signal to $pid...");

		kill($signal, $pid);

		unless (kill (0, $pid))
		{
		mtr_debug("Process $pid died.");
		delete $pids{$pid};
		}
		}

		return if scalar keys %pids == 0;

		mtr_debug("Sleeping 100ms waiting for processes to die...");

		select(undef, undef, undef, 0.1);
		}

		mtr_debug("Process(es) " .
		join(' ', keys %pids) .
		" is still alive after $total_attempts " .
		"of sending signal $signal.");
		}

		###########################################################################

		sub mtr_im_load_pids($) {
		my $instance_manager= shift;

		mtr_debug("Loading PID files...");

		# Obtain mysqld-process pids.

		my $instances = $instance_manager->{'instances'};

		for (my $idx= 0; $idx < 2; ++$idx)
		{
		mtr_debug("IM-guarded mysqld[$idx] PID file: '" .
		$instances->[$idx]->{'path_pid'} . "'.");

		my $mysqld_pid;

		if (-r $instances->[$idx]->{'path_pid'})
		{
		$mysqld_pid= mtr_get_pid_from_file($instances->[$idx]->{'path_pid'});
		mtr_debug("IM-guarded mysqld[$idx] PID: $mysqld_pid.");
		}
		else
		{
		$mysqld_pid= undef;
		mtr_debug("IM-guarded mysqld[$idx]: no PID file.");
		}

		$instances->[$idx]->{'pid'}= $mysqld_pid;
		}

		# Re-read Instance Manager PIDs from the file, since during tests Instance
		# Manager could have been restarted, so its PIDs could have been changed.

		# - IM-main

		mtr_debug("IM-main PID file: '$instance_manager->{path_pid}'.");

		if (-f $instance_manager->{'path_pid'})
		{
		$instance_manager->{'pid'} =
		mtr_get_pid_from_file($instance_manager->{'path_pid'});

		mtr_debug("IM-main PID: $instance_manager->{pid}.");
		}
		else
		{
		mtr_debug("IM-main: no PID file.");
		$instance_manager->{'pid'}= undef;
		}

		# - IM-angel

		mtr_debug("IM-angel PID file: '$instance_manager->{path_angel_pid}'.");

		if (-f $instance_manager->{'path_angel_pid'})
		{
		$instance_manager->{'angel_pid'} =
		mtr_get_pid_from_file($instance_manager->{'path_angel_pid'});

		mtr_debug("IM-angel PID: $instance_manager->{'angel_pid'}.");
		}
		else
		{
		mtr_debug("IM-angel: no PID file.");
		$instance_manager->{'angel_pid'} = undef;
		}
		}

		###########################################################################

		sub mtr_im_terminate($) {
		my $instance_manager= shift;

		# Load pids from pid-files. We should do it first of all, because IM deletes
		# them on shutdown.

		mtr_im_load_pids($instance_manager);

		mtr_debug("Shutting Instance Manager down...");

		# Ignoring SIGCHLD so that all children could rest in peace.

		start_reap_all();

		# Send SIGTERM to IM-main.

		if (defined $instance_manager->{'pid'})
		{
		mtr_debug("IM-main pid: $instance_manager->{pid}.");
		mtr_debug("Stopping IM-main...");

		mtr_im_kill_process([ $instance_manager->{'pid'} ], 'TERM', 10);
		}
		else
		{
		mtr_debug("IM-main pid: n/a.");
		}

		# If IM-angel was alive, wait for it to die.

		if (defined $instance_manager->{'angel_pid'})
		{
		mtr_debug("IM-angel pid: $instance_manager->{'angel_pid'}.");
		mtr_debug("Waiting for IM-angel to die...");

		my $total_attempts= 10;

		for (my $cur_attempt=1; $cur_attempt <= $total_attempts; ++$cur_attempt)
		{
		unless (kill (0, $instance_manager->{'angel_pid'}))
		{
		mtr_debug("IM-angel died.");
		last;
		}

		sleep(1);
		}
		}
		else
		{
		mtr_debug("IM-angel pid: n/a.");
		}

		stop_reap_all();

		# Re-load PIDs.

		mtr_im_load_pids($instance_manager);
		}

		###########################################################################

		sub mtr_im_check_alive($) {
		my $instance_manager= shift;

		mtr_debug("Checking whether IM-components are alive...");

		return 1 if mtr_im_check_main_alive($instance_manager);

		return 1 if mtr_im_check_angel_alive($instance_manager);

		return 1 if mtr_im_check_mysqlds_alive($instance_manager);

		return 0;
		}

		###########################################################################

		sub mtr_im_check_main_alive($) {
		my $instance_manager= shift;

		# Check that the process, that we know to be IM's, is dead.

		if (defined $instance_manager->{'pid'})
		{
		if (kill (0, $instance_manager->{'pid'}))
		{
		mtr_debug("IM-main (PID: $instance_manager->{pid}) is alive.");
		return 1;
		}
		else
		{
		mtr_debug("IM-main (PID: $instance_manager->{pid}) is dead.");
		}
		}
		else
		{
		mtr_debug("No PID file for IM-main.");
		}

		# Check that IM does not accept client connections.

		if (mtr_ping_port($instance_manager->{'port'}))
		{
		mtr_debug("IM-main (port: $instance_manager->{port}) " .
		"is accepting connections.");

		mtr_im_errlog("IM-main is accepting connections on port " .
		"$instance_manager->{port}, but there is no " .
		"process information.");
		return 1;
		}
		else
		{
		mtr_debug("IM-main (port: $instance_manager->{port}) " .
		"does not accept connections.");
		return 0;
		}
		}

		###########################################################################

		sub mtr_im_check_angel_alive($) {
		my $instance_manager= shift;

		# Check that the process, that we know to be the Angel, is dead.

		if (defined $instance_manager->{'angel_pid'})
		{
		if (kill (0, $instance_manager->{'angel_pid'}))
		{
		mtr_debug("IM-angel (PID: $instance_manager->{angel_pid}) is alive.");
		return 1;
		}
		else
		{
		mtr_debug("IM-angel (PID: $instance_manager->{angel_pid}) is dead.");
		return 0;
		}
		}
		else
		{
		mtr_debug("No PID file for IM-angel.");
		return 0;
		}
		}

		###########################################################################

		sub mtr_im_check_mysqlds_alive($) {
		my $instance_manager= shift;

		mtr_debug("Checking for IM-guarded mysqld instances...");

		my $instances = $instance_manager->{'instances'};

		for (my $idx= 0; $idx < 2; ++$idx)
		{
		mtr_debug("Checking mysqld[$idx]...");

		return 1
		if mtr_im_check_mysqld_alive($instance_manager, $instances->[$idx]);
		}
		}

		###########################################################################

		sub mtr_im_check_mysqld_alive($$) {
		my $instance_manager= shift;
		my $mysqld_instance= shift;

		# Check that the process is dead.

		if (defined $instance_manager->{'pid'})
		{
		if (kill (0, $instance_manager->{'pid'}))
		{
		mtr_debug("Mysqld instance (PID: $mysqld_instance->{pid}) is alive.");
		return 1;
		}
		else
		{
		mtr_debug("Mysqld instance (PID: $mysqld_instance->{pid}) is dead.");
		}
		}
		else
		{
		mtr_debug("No PID file for mysqld instance.");
		}

		# Check that mysqld does not accept client connections.

		if (mtr_ping_port($mysqld_instance->{'port'}))
		{
		mtr_debug("Mysqld instance (port: $mysqld_instance->{port}) " .
		"is accepting connections.");

		mtr_im_errlog("Mysqld is accepting connections on port " .
		"$mysqld_instance->{port}, but there is no " .
		"process information.");
		return 1;
		}
		else
		{
		mtr_debug("Mysqld instance (port: $mysqld_instance->{port}) " .
		"does not accept connections.");
		return 0;
		}
		}

		###########################################################################

		sub mtr_im_cleanup($) {
		my $instance_manager= shift;

		mtr_im_rm_file($instance_manager->{'path_pid'});
		mtr_im_rm_file($instance_manager->{'path_sock'});

		mtr_im_rm_file($instance_manager->{'path_angel_pid'});

		for (my $idx= 0; $idx < 2; ++$idx)
		{
		mtr_im_rm_file($instance_manager->{'instances'}->[$idx]->{'path_pid'});
		mtr_im_rm_file($instance_manager->{'instances'}->[$idx]->{'path_sock'});
		}
		}

		###########################################################################

		sub mtr_im_rm_file($)
		{
		my $file_path= shift;

		if (-f $file_path)
		{
		mtr_debug("Removing '$file_path'...");

		mtr_warning("Can not remove '$file_path'.")
		unless unlink($file_path);
		}
		else
		{
		mtr_debug("File '$file_path' does not exist already.");
		}
		}

		###########################################################################

		sub mtr_im_errlog($) {
		my $msg= shift;

		# Complain in error log so that a warning will be shown.
		#
		# TODO: unless BUG#20761 is fixed, we will print the warning to stdout, so
		# that it can be seen on console and does not produce pushbuild error.

		# my $errlog= "$opt_vardir/log/mysql-test-run.pl.err";
		#
		# open (ERRLOG, ">>$errlog") \|\|
		# mtr_error("Can not open error log ($errlog)");
		#
		# my $ts= localtime();
		# print ERRLOG
		# "Warning: [$ts] $msg\n";
		#
		# close ERRLOG;

		my $ts= localtime();
		print "Warning: [$ts] $msg\n";
		}

		###########################################################################

		sub mtr_im_kill($) {
		my $instance_manager= shift;

		# Re-load PIDs. That can be useful because some processes could have been
		# restarted.

		mtr_im_load_pids($instance_manager);

		# Ignoring SIGCHLD so that all children could rest in peace.

		start_reap_all();

		# Kill IM-angel first of all.

		if (defined $instance_manager->{'angel_pid'})
		{
		mtr_debug("Killing IM-angel (PID: $instance_manager->{angel_pid})...");
		mtr_im_kill_process([ $instance_manager->{'angel_pid'} ], 'KILL', 10);
		}
		else
		{
		mtr_debug("IM-angel is dead.");
		}

		# Re-load PIDs again.

		mtr_im_load_pids($instance_manager);

		# Kill IM-main.

		if (defined $instance_manager->{'pid'})
		{
		mtr_debug("Killing IM-main (PID: $instance_manager->pid})...");
		mtr_im_kill_process([ $instance_manager->{'pid'} ], 'KILL', 10);
		}
		else
		{
		mtr_debug("IM-main is dead.");
		}

		# Re-load PIDs again.

		mtr_im_load_pids($instance_manager);

		# Kill guarded mysqld instances.

		my @mysqld_pids;

		mtr_debug("Collecting PIDs of mysqld instances to kill...");

		for (my $idx= 0; $idx < 2; ++$idx)
		{
		my $pid= $instance_manager->{'instances'}->[$idx]->{'pid'};

		next unless defined $pid;

		mtr_debug(" - IM-guarded mysqld[$idx] PID: $pid.");

		push (@mysqld_pids, $pid);
		}

		if (scalar @mysqld_pids > 0)
		{
		mtr_debug("Killing IM-guarded mysqld instances...");
		mtr_im_kill_process(\@mysqld_pids, 'KILL', 10);
		}

		# That's all.

		stop_reap_all();
		}

		##############################################################################

		sub mtr_im_wait_for_connection($$$) {
		my $instance_manager= shift;
		my $total_attempts= shift;
		my $connect_timeout= shift;

		mtr_debug("Waiting for IM on port $instance_manager->{port} " .
		"to start accepting connections...");

		for (my $cur_attempt= 1; $cur_attempt <= $total_attempts; ++$cur_attempt)
		{
		mtr_debug("Trying to connect to IM ($cur_attempt of $total_attempts)...");

		if (mtr_ping_port($instance_manager->{'port'}))
		{
		mtr_debug("IM is accepting connections " .
		"on port $instance_manager->{port}.");
		return 1;
		}

		mtr_debug("Sleeping $connect_timeout...");
		sleep($connect_timeout);
		}

		mtr_debug("IM does not accept connections " .
		"on port $instance_manager->{port} after " .
		($total_attempts * $connect_timeout) . " seconds.");

		return 0;
		}

		##############################################################################

		sub mtr_im_wait_for_mysqld($$$) {
		my $mysqld= shift;
		my $total_attempts= shift;
		my $connect_timeout= shift;

		mtr_debug("Waiting for IM-guarded mysqld on port $mysqld->{port} " .
		"to start accepting connections...");

		for (my $cur_attempt= 1; $cur_attempt <= $total_attempts; ++$cur_attempt)
		{
		mtr_debug("Trying to connect to mysqld " .
		"($cur_attempt of $total_attempts)...");

		if (mtr_ping_port($mysqld->{'port'}))
		{
		mtr_debug("Mysqld is accepting connections " .
		"on port $mysqld->{port}.");
		return 1;
		}

		mtr_debug("Sleeping $connect_timeout...");
		sleep($connect_timeout);
		}

		mtr_debug("Mysqld does not accept connections " .
		"on port $mysqld->{port} after " .
		($total_attempts * $connect_timeout) . " seconds.");

		return 0;
		}

		##############################################################################

		sub mtr_im_start($$) {
		my $instance_manager = shift;
		my $opts = shift;

		mtr_debug("Starting Instance Manager...");

		my $args;
		mtr_init_args(\$args);
		mtr_add_arg($args, "--defaults-file=%s",
		$instance_manager->{'defaults_file'});

		foreach my $opt (@{$opts})
		{
		mtr_add_arg($args, $opt);
		}

		$instance_manager->{'pid'} =
		mtr_spawn(
		$::exe_im, # path to the executable
		$args, # cmd-line args
		'', # stdin
		$instance_manager->{'path_log'}, # stdout
		$instance_manager->{'path_err'}, # stderr
		'', # pid file path (not used)
		{ append_log_file => 1 } # append log files
		);

		if ( ! $instance_manager->{'pid'} )
		{
		mtr_report('Could not start Instance Manager');
		return;
		}

		# Instance Manager can be run in daemon mode. In this case, it creates
		# several processes and the parent process, created by mtr_spawn(), exits just
		# after start. So, we have to obtain Instance Manager PID from the PID file.

		if ( ! sleep_until_file_created(
		$instance_manager->{'path_pid'},
		$instance_manager->{'start_timeout'},
		-1)) # real PID is still unknown
		{
		mtr_report("Instance Manager PID file is missing");
		return;
		}

		$instance_manager->{'pid'} =
		mtr_get_pid_from_file($instance_manager->{'path_pid'});

		mtr_debug("Instance Manager started. PID: $instance_manager->{pid}.");

		# Wait until we can connect to IM.

		my $IM_CONNECT_TIMEOUT= 30;

		unless (mtr_im_wait_for_connection($instance_manager,
		$IM_CONNECT_TIMEOUT, 1))
		{
		mtr_debug("Can not connect to Instance Manager " .
		"in $IM_CONNECT_TIMEOUT seconds after start.");
		mtr_debug("Aborting test suite...");

		mtr_kill_leftovers();

		mtr_error("Can not connect to Instance Manager " .
		"in $IM_CONNECT_TIMEOUT seconds after start.");
		}

		# Wait until we can connect to guarded mysqld-instances
		# (in other words -- wait for IM to start guarded instances).

		for (my $idx= 0; $idx < 2; ++$idx)
		{
		my $mysqld= $instance_manager->{'instances'}->[$idx];

		next if exists $mysqld->{'nonguarded'};

		mtr_debug("Waiting for mysqld[$idx] to start...");

		unless (mtr_im_wait_for_mysqld($mysqld, 30, 1))
		{
		mtr_debug("Can not connect to mysqld[$idx] " .
		"in $IM_CONNECT_TIMEOUT seconds after start.");
		mtr_debug("Aborting test suite...");

		mtr_kill_leftovers();

		mtr_error("Can not connect to mysqld[$idx] " .
		"in $IM_CONNECT_TIMEOUT seconds after start.");
		}

		mtr_debug("mysqld[$idx] started.");
		}

		mtr_debug("Instance Manager started.");

		mtr_im_load_pids($instance_manager);
		}

		##############################################################################

		sub mtr_im_stop($$) {
		my $instance_manager= shift;
		my $where= shift;

		mtr_debug("Stopping Instance Manager...");

		# Try graceful shutdown.

		mtr_im_terminate($instance_manager);

		# Check that all processes died.

		unless (mtr_im_check_alive($instance_manager))
		{
		mtr_debug("Instance Manager has been stopped successfully.");
		mtr_im_cleanup($instance_manager);
		return 1;
		}

		# Instance Manager don't want to die. We should kill it.

		mtr_im_errlog("[$where] Instance Manager did not shutdown gracefully.");

		mtr_im_kill($instance_manager);

		# Check again that all IM-related processes have been killed.

		my $im_is_alive= mtr_im_check_alive($instance_manager);

		mtr_im_cleanup($instance_manager);

		if ($im_is_alive)
		{
		mtr_error("Can not kill Instance Manager or its children.");
		return 0;
		}

		mtr_debug("Instance Manager has been killed successfully.");
		return 1;
		}

		###########################################################################

		1;

mysql-test/mysql-test-run.pl

+12 −251

File changed.

Preview size limit exceeded, changes collapsed.

mysql-test/r/grant.result

+26 −1

File changed.

Preview size limit exceeded, changes collapsed.

mysql-test/r/im_cmd_line.result

+7 −0

Original line number	Diff line number	Diff line
		SHOW VARIABLES LIKE 'server_id';
		Variable_name Value
		server_id 1
		SHOW INSTANCES;
		instance_name state
		mysqld1 starting
		mysqld2 offline
		--> Listing users...
		im_admin

mysql-test/r/im_instance_conf.result

+7 −11

Original line number	Diff line number	Diff line
		--------------------------------------------------------------------
		server_id = 1
		server_id = 2
		--------------------------------------------------------------------
		SHOW VARIABLES LIKE 'server_id';
		Variable_name Value
		server_id 1
		SHOW INSTANCES;
		instance_name state
		mysqld1 online
		mysqld2 offline

		---> connection: mysql1_con
		SHOW VARIABLES LIKE 'server_id';
		Variable_name Value
		server_id 1

		---> connection: default
		--------------------------------------------------------------------
		server_id = 1
		server_id = 2
		--------------------------------------------------------------------
		CREATE INSTANCE mysqld3
		server_id = 3,
		socket = "$MYSQL_TMP_DIR/mysqld_3.sock";