Re: oaf-slay improvements

[Brian Cameron <Brian Cameron sun com>]

Olaf:

> > If there is a standard Perl module that can be used, point me towards it
> > and I'll happily update the script to use it.
> [snip]
> Don't know if it is standard, but Proc::ProcessTable.
> 
> 
http://cpan.valueclick.com/modules/by-category/04_Operating_System_Interfaces/P
> roc/DURIST/

Thanks for this suggestion.  This code does seem to do exactly what we
would like.  However I don't think this is useable yet for a number of
reasons.

1) It is clearly labelled as "beta" code.  I'm not sure that OAF wants such
   beta code as a dependancy.
2) It is not in the standard Perl distributions yet, so if oaf-slay makes
   use of this code, then oaf-slay will have to be bundled with this Perl
   module.  In addition it has the "Storable" and "Find" modules as 
   dependencies.  None of these modules are on the Perl 5.003 installation
   (the Solaris default).  Once we track down the whole depenency chain,
   I suspect we would possibly have more depenencies.  Setting all this
   up seems like more of a hassle than it is worth.
3) I looked through the code and the OS-dependant "ps" code is all written
   in C and isn't easy to extract into my Perl script via cut & paste.
   
Any other ideas?  Frankly it seems like it just would be easier for someone
using SYSV to hack the script to work with their ps command.  Unless someone
who is more ambitious wants to try an integrate this Proc:ProcessTable
code into the oaf-slay script.

Here's the latest version which uses the "USER" environment variable instead
of "whoami" which was causing the other OS-dependency.

Brian

#!/usr/bin/perl
# 
# oaf-slay
# 
# Kills OAF processes
#
# Return code of -1 (255) returned if usage error.
# Return code of 1 indicates oaf processes were running
#   when script was run.  
# Return code of 0 indicates no oaf processes were
#   running when script was run.
#
use             Getopt::Std;

$usage_error = 0;

# Handle input arguments
#
$rc = getopts('lsh');

# Usage errors
#
if ($rc != 1) {
   $usage_error = 1;
}

if ($opt_l && $opt_s) {
   $usage_error = 1;
}

# Print usage if necessary.
#
if ($usage_error == 1 || $opt_h) {
	print "\n";
	print "Usage : oaf-slay [-hls]\n";
	print "\tKill OAF processes still running.\n";
	print "\t -h Print this help message.\n";
	print "\t -l List processes running, but do not kill them.  Not valid with -s\n";
	print "\t -s Silent.  Kill processes quietly\n";
	print "\n";
	exit(-1);
}

# Build ps command.
#
$username = $ENV{'USER'};

chomp($username);
$ps_cmd = "/bin/ps -e -opid,user,args | /bin/grep ".$username;

# get OAF files
#
@path = split(':', $ENV{'PATH'});

foreach $dir (@path) {
	if (-f "$dir/oafd") {
		$ins_dir  = `/usr/bin/dirname $dir`;
		chomp $ins_dir;
		$oaf_dir  = $ins_dir . "/share/oaf";
		last;
	}
}

chdir($oaf_dir);
opendir(DIR, $oaf_dir) || die "\nCan not open directory $oaf_dir\n\t$!\n\n";
@oaf_files = readdir(DIR);
closedir DIR;

# Initialize variables
#
$process_exists = 0;
$first_time     = 1;

# Loop until no more processes are found.  This typically loops only once,
# but if an OAF process is launched while this script is running an OAF
# process can be left behind and be caught on the second loop, etc.
#
do {
	# Initialize variables.
	#
	@files        = @oaf_files;
	@list_array   = ();
	@process_pids = ();
	@file_process = ();
	$index        = 0;

	# Get process list.
	#
	@ps_result    = `$ps_cmd`;

	# Loop through files, and see if any OAF processes are running.  If
	# so, then build the @list_array and @process_pids arrays.
	# @list_array contains the process names
	# @process_pids contains the process IDs
	#
	while ($fname = shift(@files)) {

		if ("$fname" =~ /\.oaf$/) {
		
			open(FILE, $fname);
			while (<FILE>) {

				$line = $_;
				if  ($line =~m/location[ \t]*\=/ && 
				   !($line =~m/type=\"shlib\"/)) {
	
					$line =~s/.*location[ \t]*\="//;
					$line =~s/".*//;
					chomp($line);
					$line =~s/\.\///;

					# oafd needs to be last.
					#
					if ($line ne "oafd") {
						push @file_process, $line;
					}
				} #end while(<FILE>)
			}
			close(FILE);
		}
	}

	# Add oafd so that it is last.
	#
 	push @file_process, "oafd"; 

	foreach $filep (@file_process) {

		if (not($filep =~m/^OAFIID:/)) {

			# Search through @ps_result and look for matches
			#
			foreach $el (@ps_result) {
				chomp $el;
				if ($el =~m/$filep/ ) {
					@ps_array = split(' ', $el);
					$list_array[$index]=$ps_array[0]."\t".$ps_array[2]."\n";
					$process_pids[$index]=$ps_array[0]."\n";
					$index++;
					}
				}
			}
		}

	# Do the killing.
	#
	if ($#list_array != -1) {

		# Print output if -s (silent) argument is not specified.
		#
		if(!$opt_s) {
			if ($first_time == 1) {
				print "\n";
				print "The following processes are still running on the system.\n";

				if (!$opt_l) {
					print "These processes will be terminated.\n";

					print "\n";
					print "NOTE:  Killing these processes may affect other applications\n";
					print "on the system that use OAF and bonobo.\n"; 
				}
				print "\n";
				$first_time = 0;
			} else {
				# Just some feedback to indicate it had to loop...
				#
				print "...and...\n";
			}

			# Print list of processes...
			#
			print @list_array;
			print "\n";
		}

		# Kill if the -l argument is specified.
		#
		if(!$opt_l) {
			$killall = "/bin/kill";
			$kill_params = ' -9 ';
			foreach $proc (@process_pids) {
				chomp $proc;
				if($proc =~m/\d+/) {
					$cmd = $killall.$kill_params.$proc." 2>/dev/null";
					system($cmd);
				}
			}	
		}
		$process_exists = 1;
	}

# Only loop once if opt_l is used, otherwise loop until
# no more processes are killed
#
} while ($#list_array != -1 && !opt_l);
 
# Exit
#
if ($process_exists == 0) {

	# Show feedback if -l argument is used
	#
	if ($opt_l) {
		print "\n";
		print "No processes.\n";
		print "\n";
	}
	exit 1;
} else {
	exit 0;
}