sshotgun 1.0.4 → 1.0.5

data/README.rdoc

@@ -10,8 +10,12 @@ The author of SSHotgun is Vick Perry (vick.perry @nospam@ gmail.com)
 
 SShotgun is a utility library for writing Unix/Linux server management and
 provisioning scripts in Ruby. I use it for remotely managing machines in server
-clusters/farms.  SShotgun uses your locally installed SSH client and expects
-that you have your SSH public key installed on the servers.  
+clusters/farms.  
+
+SShotgun calls your locally installed SSH client.  Before you do anything with
+SSHotgun, insure that your SSH public keys are installed correctly, the
+ssh-agent is running, that you've entered your passphrase via ssh-add and you
+can successfully log into the remote servers without getting a password prompt.
 
 == FEATURES:
 
@@ -202,26 +206,26 @@ script). See the advanced example for details.
 Below is an advanced example that illustrates additional capabilities.
 
   #!/usr/bin/env ruby
-  
+
   # Required libraries
   require "highline/import"
   require 'sshotgun'
-  
+
   # Create array to contain hosts for processing
   hostlist = Array::new()
   host = HostDefinition.new("someserver.junk", "test", "ubuntu_server_7.10", "test vm")
   hostlist << host
-  
-  # Import a list of host definitions
+
+  # Import an external (shared) list of host definitions
   require 'listofhosts'
   hostlist = hostlist + ListOfHosts.getHostlist
-  
+
   class MyProcessingClass < BaseProcessingClass
-  
+
     # You can add your own Ruby instance variables. These are useful if you
     # want to share data across your own custom methods.
     attr_accessor :myInstanceVariable
-  
+
     # You MUST define a doProcessing method. Note that to make the doProcessing
     # method less cluttered, you can also create your own methods that are
     # called from within the doProcessing method. You can use your own accessor
@@ -230,27 +234,81 @@ Below is an advanced example that illustrates additional capabilities.
     def doProcessing
       # Log the beginning of this method. This marker is useful for debugging problems.
       log "[" + @hostdef.hostname + "] info: " + "Processing started"
-  
-      # Execute a command on all remote servers.  Remote output is always written
-      # to this script's stdout.
-      # run <command>
-      run "ls -aF | grep -i .bash"
-  
+
+      # Sometimes a remote server is unavailable. I like to include a check at
+      # top of the doProcessing method to stop processing for that server. This
+      # snippet works because if a server is down, unreachable or non-responsive
+      # then the id lookup for yourself will fail - when this happens call
+      # "return" to drop out of this method.
+      # Ruby's ENV contains the current user (you)
+      currentUser = ENV["USER"].to_s
+      runstatus = run "id " + currentUser
+      if runstatus.exitstatus != 0
+        log "[" + @hostdef.hostname + "] info: " + "Server not available or you cannot log in. Stopping processing for this server"
+
+        # Set the status field for this host to indicate an abort. This status
+        # will be displayed upon termination of the script
+        @hostdef.status = "aborted"
+
+        # return will end the processing of this host
+        return
+      else
+        # set status to indicate that processing for this host has started
+        @hostdef.status = "started"
+      end
+
+      # Compound commands in many shells may be created via the ";" semicolon
+      # separator.
+      run "ls -alF; printenv"
+
+      # Escape any quotes (single or double) that are included within the command
+      # string. Surround the shell command string with single quotes or %q() in
+      # the sshotgun script so that Ruby won't interpolate the escaped characters
+      # before passing them to the your local ssh client.
+      run 'ls -aF | grep -i \".bash*\"'
+      run %q(ls -aF | grep -i \".bash*\")   
+
+      # Run the command under sudo on the remote machine. If you run runSudo
+      # commands then the SSHotgun.sudoPassword must be set - uncomment the user
+      # prompt that sets the sudoPassword at the bottom of this script. See the
+      # gotcha below when running compound commands via sudo.
+      #runSudo "somecommand"
+      
+      # A gotcha with sudo in unix is that is that security is tightened by
+      # restricting the process environment. This means that compound commands
+      # that use built-in shell functions such as "cd" or "pushd" will fail.  To
+      # overcome this, first spawn a new shell, then pass it the commands to run.
+      # Note that because the command string contains escaped characters, you
+      # must enclose the entire command string in single quotes.
+      #runSudo 'bash -c \"hostname;pushd /tmp;hostname;ls -alf;popd\"'
+
+      # THIS WON'T WORK - SUDO can't find pushd and popd unless you spawn a shell first
+      #runSudo "hostname;pushd /tmp;hostname;ls -alf;popd"  
+
+      # On the remote server, the run and runSudo commands are executed in a
+      # non-interactive shell. This means that many of the environment variables
+      # that are set when you log in interactively will be missing. For debugging
+      # purposes, call 'printenv' to view the environment variables.
+      #run "printenv"
+    
+      # A useful technique is set environment variables via a compound command.
+      #run "export http_proxy=aaa.bbb.com/8080/;wget www.mysite.junk/mypage"
+
       # The runstatus object is returned from all run and runSudo calls.
       # runstatus contains information about exit status, stdout and stderr from
       # the remote server.
-      runstatus = run "ls -aF"
-  
+      runstatus = run "ls -aF .bash*"
+
       # Use the log method to write to the log (the console). Don't use the Ruby
       # 'puts' method to write to the console because it isn't threadsafe and may
       # mix and garble simultaneous output by multiple threads.
       log "[" + @hostdef.hostname + "] info: " + "The exit status of the run command is " + runstatus.exitstatus.to_s
-  
+
       # Remote stderr and stdout are captured and stored in the stdoutstr and
       # stderrstr variables. Learn about Ruby's regular expressions for examining
       # the output from a remote command.
       runstatus = run "id rumplestiltskin"
-  
+
       # Check for "No such user" contained in stdoutstr. That's what is displayed
       # when the unix "id" command can't find the specified user. Note that the
       # the exit status of a failed 'id' command is not equal to zero either (see
@@ -258,18 +316,18 @@ Below is an advanced example that illustrates additional capabilities.
       if /No such user/ =~ runstatus.stdoutstr
         log "I failed to find user rumplestiltskin on this server"
       end
-  
+
       # In some cases a remote command fails and you must stop processing for
       # that one server. Stop the execution of the doProcessing method by calling
       # Ruby's "return" statement. Don't call Ruby's "exit" statement because
       # that will halt all running threads.
-  #    runstatus = run "id rumplestiltskin"
-  #    if runstatus.exitstatus > 0
-  #      log "The exit code was not 0, therefore I failed to find user rumplestiltskin"
-  #      return  # stop processing for this host
-  #    end
-  #    log "You'll never get here...unless you have a user named rumplestiltskin"
-  
+      #runstatus = run "id rumplestiltskin"
+      #if runstatus.exitstatus > 0
+      #  log "The exit code was not 0, therefore I failed to find user rumplestiltskin"
+      #  return  # stop processing for this host
+      #end
+      #log "You'll never get here...unless you have a user named rumplestiltskin"
+
       # The @hostdef instance variable contains the host definition for the
       # current host being processed. If you set category, os and desc to
       # meaningful information then you can do fancier branching logic in your
@@ -280,97 +338,99 @@ Below is an advanced example that illustrates additional capabilities.
       log "The current host's category is: " + @hostdef.category
       log "The current host's os is: " + @hostdef.os
       log "The current host's description is: " + @hostdef.desc
-  
+      log "The current host's status is: " + @hostdef.status
+
       # Target a specified host. This is a Ruby string comparison.
       if @hostdef.hostname == "192.168.1.224"
         log "[" + @hostdef.hostname + "] info: " + "Special processing for this host"
       end
-  
-      # If necessary, escape any quotes within the command.  that must be passed
-      # through to the remote server. This isn't a great example but you'll need
-      # to do this for tricky shell scripting.
-      run "ls -aF | grep -i \".bash\""
-  
-      # If you are running any runSudo commands then the SSHotgun.sudoPassword
-      # must be set - uncomment the user prompt and setting of the sudoPassword
-      # at the bottom of this script. Don't set up your servers to permit a
-      # password-less sudo - it is a security risk. Watch out, the "runSudo"
-      # command and Ruby in general, are case sensitive.
-      # runSudo <command>
-  #    runSudo "touch /usr/local/bin/mytest.txt"
-  #    run "ls -alF /usr/local/bin/"
-  #    runSudo "rm /usr/local/bin/mytest.txt"
-  
+
       # Run a command locally (on your local machine). The runstatus variable is
       # returned if you need the data - same as run or runSudo.
       # runLocal <command> 
-  #    runLocal "ls -alF"
-  
+      #runLocal "ls -alF"
+
       # Run a sudo command locally. The runstatus variable is returned if you
       # need data from it. Set a sudoPassword if you are calling runLocalSudo.
       # runLocalSudo <command> 
-  #    runLocalSudo "ls -alF"
-  
+      #runLocalSudo "ls -alF"
+
       # Create a remote file from a string parameter.
       # createRemoteFile <content string>, <remotefile>
-  #    createRemoteFile "this is your content here", "/home/vickp/testfile.txt"
-  
+      #createRemoteFile "this is your content here", "/home/vickp/testfile.txt"
+
       # Create a remote file and set mode
       # createRemoteFile <content string>, <remotefile>, <mode string>
-  #    createRemoteFile "this is your content here", "/home/vickp/testfile.sh", "0755"
+      #createRemoteFile "this is your content here", "/home/vickp/testfile.sh", "0755"
       
       # Copy a remote file to the local machine. Note that you should vary the
       # name of the incoming local file else it will be overwritten when each
       # host's file is copied.
       # copyRemoteFileToLocal <remotefile>, <localfile>
-  #    copyRemoteFileToLocal "/home/vickp/testfile.txt", "/home/vickp/temp/" + @hostdef.hostname + "_testfile.txt" 
+      #copyRemoteFileToLocal "/home/vickp/testfile.txt", "/home/vickp/temp/" + @hostdef.hostname + "_testfile.txt" 
       
       # Copy a remote file to the local machine and set the mode of local file.
       # copyRemoteFileToLocal <remotefile>, <localfile>, <mode string>
-  #    copyRemoteFileToLocal "/home/vickp/testfile.txt", "/home/vickp/temp/" + @hostdef.hostname + "_testfile.txt", "0644"
+      #copyRemoteFileToLocal "/home/vickp/testfile.txt", "/home/vickp/temp/" + @hostdef.hostname + "_testfile.txt", "0644"
       
       # Copy a local file to the remote machine.
       # copyRemoteFileToLocal <localfile>, <remotefile>
-  #    copyLocalFileToRemote "/home/vickp/temp/testfile.txt", "/home/vickp/testfile2.txt"
+      #copyLocalFileToRemote "/home/vickp/temp/testfile.txt", "/home/vickp/testfile2.txt"
       
       # Copy a local file to the remote machine and set the mode of remote file.
       # copyRemoteFileToLocal <localfile>, <remotefile>, <mode string>
-  #    copyLocalFileToRemote "/home/vickp/temp/testfile.txt", "/home/vickp/testfile2.txt", "0644"
-  
+      #copyLocalFileToRemote "/home/vickp/temp/testfile.txt", "/home/vickp/testfile2.txt", "0644"
+
       # Other helpful SSHotgun and Ruby tips below
       # ===========================================
-  
+
       # Ruby allows you to concatenate multiple command lines
       # Note use of shell command separator ';'
-  #    cmd = "ls -alF;"
-  #    cmd << "ls -alF | grep -i .bash;"
-  #    cmd << "ls -alF | grep -i .profile"
-  #    run cmd
-  
+      cmd = "hostname;"
+      cmd << "ls -alF | grep -i .bash;"
+      cmd << "ls -alF | grep -i .profile"
+      run cmd
+
       # Delete a file on the remote server.
       # Note use of -f with rm command
-  #    run "rm -f /path/to/remote/file"
-  
+      #run "rm -f /path/to/remote/file"
+
+      # Determine if a directory exists on the remote server
+      runstatus = run 'test -d \"/tmp\"'
+      if runstatus.exitstatus > 0
+        log "[" + @hostdef.hostname + "] info: " + "The /tmp directory does NOT exist"
+      else
+        log "[" + @hostdef.hostname + "] info: " + "The /tmp directory exists"
+      end
+
+      # Determine if a file exists on the remote server
+      runstatus = run 'test -e \".profile\"'
+      if runstatus.exitstatus > 0
+        log "[" + @hostdef.hostname + "] info: " + ".profile does NOT exist"
+      else
+        log "[" + @hostdef.hostname + "] info: " + ".profile exists"
+      end
+
       # Call your own methods to unclutter and better organize your doProcess
       # method code. In most of my SSHotgun scripts the doProcess method is
       # fairly sparse - most of the work is done is various custom methods that
       # are called within the doProcess method
-  #    myOwnMethod
-  
-      # Sometimes I either install unsigned packages of my own (shell and ruby
-      # scripts) or need to force the installation of files (overwrite) that
+      #myOwnMethod
+
+      # The SSHotgun instance variables are visible in this method. 
+      log "[" + @hostdef.hostname + "] info: " + "The script started at: " + @sshotgun.startTime.to_s
+
+      # Sometimes I either install unsigned debian packages of my own
+      # or need to force the installation of files (overwrite) that
       # belong to another package. Aptitude doesn't yet support forcing yes for
       # this sort of thing but apt-get does...
-  #    runSudo "apt-get install -y --force-yes myUntrustedPackage -o DPkg::options::='--force-overwrite'"
-  
-      # Ruby's ENV contains the current user (you)
-      currentUser = ENV["USER"].to_s
-  
+      #runSudo "apt-get install -y --force-yes myUntrustedPackage -o DPkg::options::='--force-overwrite'"
+
       # For double quoted strings, Ruby will do inline substitution for a
       # variable enbedded within "#{myvariablehere}". This is useful when you
       # want a variable substituted inside of double quotes
-  #    createRemoteFile "deb http://debrepo/global ./", "/home/#{currentUser}/sources.list", "0644"
-  
+      #createRemoteFile "deb http://debrepo/global ./", "/home/#{currentUser}/sources.list", "0644"
+
       # Create a global variable if you need to prompt for additional information
       # (such as userid, date range, etc) and want to use that information in
       # your doProcessing method. Global variables begin with '$'. See bottom of
@@ -382,27 +442,27 @@ Below is an advanced example that illustrates additional capabilities.
       else
         log "[" + @hostdef.hostname + "] info: " + "DID NOT find user " + $userid
       end
-  
-      # To pass escaped characters in strings, tell Ruby not to interpolate them
-      # by using single quotes or the %q() delimiter to enclose the escaped
-      # string.  This means that Ruby will not attempt to resolve the escaped
-      # string but merely pass it on to the ssh client.
-  #    run %q("mycommand \"some\ string\ with\ escapes\" more")
-  
-      # Example of how to update a debian/ubuntu sources.list package repository file
+
+      # See example of how to update a debian/ubuntu sources.list package repository file
       # Also see use of case statement in the method body.
-  #    installSourcesListAndUpdate
-  
+      #installSourcesListAndUpdate
+
+      # You can set the exit code of this script
+      #@sshotgun.exitCode = 3
+
       # Log the end of this method.
       log "[" + @hostdef.hostname + "] info: " + "Processing completed"
+
+      # Set the status field for this host to indicate successful processing.
+      @hostdef.status = "finished"
     end
   end
-  
+
   # Your own custom methods can be called from within the doProcess method
   def myOwnMethod
     log "[" + @hostdef.hostname + "] info: " + "Calling my own method"
   end
-  
+
   # Update a debian/ubuntu /etc/apt/sources.list
   def installSourcesListAndUpdate
     # WARNING: This only works if you fill in the category field in your hostdefs.
@@ -432,25 +492,25 @@ Below is an advanced example that illustrates additional capabilities.
     createRemoteFile s, "/home/#{$currentUser}/sources.list", "0644"
     runSudo "cp /home/#{$currentUser}/sources.list /etc/apt/sources.list"
     run "rm /home/#{$currentUser}/sources.list"
-  
+
     # after changing sources.list, update package manager to refresh package list
     runSudo "aptitude update"
   end
-  
+
   # Create an instance of SSHotgun and pass it the list of hosts and your custom
   # processing class.
   sshotgun = SSHotgun.new(hostlist, MyProcessingClass)
-  
+
   # If you are calling a sudo command then prompt the user for the sudo password.
   # I recommend that you NEVER HARDCODE A PASSWORD IN A SCRIPT!  Configure the
   # ask command to hide the password as the user types it.  Note that the you
   # must have the highline gem package installed for the "ask" command
   #sshotgun.sudopassword = ask(">>> Enter your sudo password:  ") { |q| q.echo = "*" } # or q.echo = false
-  
+
   # If you need to forward all calls via a gateway ssh server, set it here.  Once
   # set, all ssh connections go through the gateway machine
   #sshotgun.gatewayhost = "someserver.somedomain.com"
-  
+
   # You can also use the 'ask' command to prompt the user for any other
   # information. Configure the ask command to display the string as the user
   # types it. Be sure to test password-less login from your gateway server to
@@ -458,26 +518,30 @@ Below is an advanced example that illustrates additional capabilities.
   # host.
   #gatewayhost = ask(">>> Enter the hostname of the gateway server:  ") { |q| q.echo = true }
   #sshotgun.gatewayhost = gatewayhost
-  
+  #sshotgun.gatewayhost = "mygateway.hostname.junk"
+
   # Create and use a global variable to get additional data into your doProcessing method.
   $userid = ask(">>> Enter the userid to find:  ") { |q| q.echo = true }
-  
+
   # Number of simultaneous processing threads (hosts) to run. In terms of load to
   # your local machine, each processing thread equates to about one ssh client
   # running. Default is 50
   # sshotgun.maxThreads = 30    
-  
+
   # A processing thread will be killed after this amount of time. Default is 30 minutes.
   # sshotgun.threadTimeoutInSeconds = 900
-  
+
   # Period for displaying status information about processing threads that
   # are still running. Default is 30
   # sshotgun.monitorPollIntervalInSeconds = 20
-  
+
   # Any output is also written to a file logger. You can disable the file logging
   # by setting isFileLogging to false.
   # sshotgun.isFileLogging = false.
-  
+
+  # Turn on debug mode
+  # sshotgun.isDebug = true
+
   # What should the behavior be when a command returns a non-zero exit status? A
   # non-zero exit status usually indicates failure of the command. Some sshotgun
   # users wish to immediately stop the processing for that server and stop it's
@@ -487,10 +551,11 @@ Below is an advanced example that illustrates additional capabilities.
   # you never have the opportunity to check the exit status in your processing
   # method code. The default is false (don't stop on non-zero exit).
   # sshotgun.isStopOnNonZeroExit = true
-  
+
   # Start processing. The start call should be the very last line in a SSHotgun
   # script.
   sshotgun.start
+
   
 == LICENSE:
 

data/lib/sshotgun.rb

@@ -3,6 +3,19 @@
 #Copyright:: Copyright (c) 2008, Vick Perry
 #License::   Simplified BSD License.
 #
+# vickp 9/24/2008, Added HostDefinition.status freeform text field. Upon
+# termination of the script, the status field is displayed for each host.
+# Typically set by the script programmer to indicate state of processing. E.g.
+# "started", "aborted", "finished", etc. Removed original status flags.
+#
+# vickp 9/23/2008, Added SSHotgun.exitCode (fixnum). So that programmer can set
+# the script's exit code. Exit code is returned to calling process upon termination.
+#
+# vickp 9/23/2008, Added check for unescaped quotes in command strings.  Added
+# isDebug flag. Updated documents with clarification about escaping quotes in
+# command strings and tips about how to deal with a restricted unix environment
+# when using sudo.
+#
 require 'open4'
 require 'logger'
 
@@ -21,24 +34,15 @@ class HostDefinition
   # desc is a one sentence string describing main purpose of the host (optional)
   attr_accessor :desc
 
-  # For internal use. True if processing was done for this server.
-  attr_accessor :startedProcess
-
-  # For internal use. True if processing was finished for this server. This means that doProcess exited
-  # normally with no exceptions. 
-  attr_accessor :finishedProcess
-
-  # For internal use. True if one or more commands on a server returned with a non-zero exit status
-  attr_accessor :hadNonZeroExitStatus
+  # status is freeform text field that the script programmer can set. Generally set to "started", "finished", "aborted", etc.
+  attr_accessor :status
 
   def initialize(hostname, category = "", os = "", desc = "")
     @hostname = hostname
     @category = category
     @os = os
     @desc = desc
-    @startedProcess = false
-    @finishedProcess = false
-    @hadNonZeroExitStatus = false
+    @status = ""
   end
 end
 
@@ -92,12 +96,19 @@ class BaseProcessingClass
   #
   def run(cmd)
     log "[" + @hostdef.hostname + "] run: " + cmd
-    if @sshotgun.gatewayhost
-      cmdline = "ssh -A -t -x " + @sshotgun.gatewayhost + " 'ssh -A -x " +  @hostdef.hostname + " \"" + cmd + "\"'"
+    if !hasUnescapedQuotes(cmd)
+      if @sshotgun.gatewayhost
+        cmdline = "ssh -A -t -x " + @sshotgun.gatewayhost + " 'ssh -A -x " +  @hostdef.hostname + " \"" + cmd + "\"'"
+      else
+        cmdline = "ssh -A -t -x " +  @hostdef.hostname + " \"" + cmd + "\""
+      end
+      runLocal cmdline, false
     else
-      cmdline = "ssh -A -t -x " +  @hostdef.hostname + " \"" + cmd + "\""
+      log "[_sshotgun_] fatal: Command string cannot contain unescaped quotes. Surround command string"
+      log "[_sshotgun_] fatal: with single quotes or %q() so that Ruby does not interpolate string first."
+      @sshotgun.exitCode = 1
+      @sshotgun.showRunStatsAndExit
     end
-    runLocal cmdline, false
   end
 
   # Sudo a command on a remote server
@@ -108,12 +119,19 @@ class BaseProcessingClass
   #
   def runSudo(cmd)
     log "[" + @hostdef.hostname + "] runSudo: " + cmd
-    if @sshotgun.gatewayhost
-      cmdline = "ssh -A -t -x " + @sshotgun.gatewayhost + " 'ssh -A -x " + @hostdef.hostname + " sudo -S \"" + cmd + "\"'"
+    if !hasUnescapedQuotes(cmd)
+      if @sshotgun.gatewayhost
+        cmdline = "ssh -A -t -x " + @sshotgun.gatewayhost + " 'ssh -A -x " + @hostdef.hostname + " sudo -S \"" + cmd + "\"'"
+      else
+        cmdline = "ssh -A -t -x " + @hostdef.hostname + " sudo -S \"" + cmd + "\""
+      end
+      runLocal cmdline, true
     else
-      cmdline = "ssh -A -t -x " + @hostdef.hostname + " sudo -S \"" + cmd + "\""
+      log "[_sshotgun_] fatal: Command string cannot contain unescaped quotes. Surround command string"
+      log "[_sshotgun_] fatal: with single quotes or %q() so that Ruby does not interpolate string first."
+      @sshotgun.exitCode = 1
+      @sshotgun.showRunStatsAndExit
     end
-    runLocal cmdline, true
   end
 
   # Copy a remote file to local
@@ -180,7 +198,10 @@ class BaseProcessingClass
   # isSudo is the flag to launch as a sudo command
   #
   def runLocal (cmdline, isSudo=false)
-    #log "[" + @hostdef.hostname + "] debug: " + cmdline
+    if @sshotgun.isDebug
+      # display & log the actual command line sent to ssh
+      log "[" + @hostdef.hostname + "] debug: raw command line to local ssh client: " + cmdline
+    end
     currentThread = Thread.current
     runstatus = RunStatus.new
     retval = Open4::popen4( cmdline ) do |pid, stdin, stdout, stderr|
@@ -188,6 +209,8 @@ class BaseProcessingClass
       if isSudo
         if @sshotgun.sudopassword
           stdin.puts @sshotgun.sudopassword
+        else
+          log "[" + @hostdef.hostname + "] info: sudo invoked but sudo password is blank"
         end
       end
       runstatus.stdoutstr = stdout.read.strip
@@ -202,10 +225,6 @@ class BaseProcessingClass
     runstatus.exitstatus = retval.exitstatus
 
     if runstatus.exitstatus != 0
-      # set flag to indicate a non-zero exit status
-      # this flag is needed by the status report at the end of the script run
-      @hostdef.hadNonZeroExitStatus = true
-      
       # am I supposed to stop thread?
       if @sshotgun.isStopOnNonZeroExit
         log "[" + @hostdef.hostname + "] stderr: Non-zero exit status - Stop processing for this server (" + runstatus.exitstatus.to_s + ")"
@@ -235,6 +254,30 @@ class BaseProcessingClass
   def log(s)
     @sshotgun.log s
   end
+
+  # Does the string contain unescaped quotes? This is a safety measure.  If
+  # there are unescaped quotes (double or single) contained in a command
+  # string, it may be interpolated differently than as is expected. For example
+  # a compound command may execute the first part on a local or gateway server
+  # and the last part on the remote server. 
+  #
+  # s is the string to check
+  #
+  def hasUnescapedQuotes(s)
+    retval = false
+    previousChar = ""
+    sArray = s.split(//)
+    sArray.each do |currentChar|
+      #log currentChar
+      if (currentChar == "\"" || currentChar == "\'") && previousChar != "\\"
+        retval = true
+        break
+      end
+      previousChar = currentChar
+    end
+    return retval
+  end
+
 end
 
 # This is the main class of SSHotgun. This class stores the configuration and launches the processing threads.
@@ -270,15 +313,24 @@ class SSHotgun
   # For internal use. Mutex for launching processing threads
   attr_reader :threadStartMutex
 
+  # For internal use. Mutex for exiting
+  attr_reader :threadEndMutex
+
   # File logger. Set your own if desired. (optional)
   attr_accessor :filelogger
 
   # Turn on/off file logging. Default is on. (optional)
   attr_accessor :isFileLogging
 
+  # Turn on/off debugging. Default is off. (optional)
+  attr_accessor :isDebug
+
   # For internal use. Script start time
   attr_reader :startTime
 
+  # For internal use. sshotgun version
+  attr_reader :versionStr
+
   # Turn on/off behavior where processing for a server is stopped if any
   # command (run, runSudo, etc) returns with a non-zero exit code. Default is
   # off (don't stop). Note that if isStopOnNonZeroExit is true then the
@@ -286,11 +338,16 @@ class SSHotgun
   # check the exit status in your processing code.
   attr_accessor :isStopOnNonZeroExit
 
+  # Exit code for this script, default is zero. Settable by the script programmer.
+  attr_accessor :exitCode
+
   def initialize(hostlist, processingclass)
+    @versionStr = "1.0.5"
     @hostlist = hostlist
     @processingclass = processingclass
     @logmutex = Mutex.new
     @threadStartMutex = Mutex.new
+    @threadEndMutex = Mutex.new
     @maxThreads = 30  # allow NN processing threads to run at any time
     @threadTimeoutInSeconds = 1800  # timeout after 30 minutes
     @monitorPollIntervalInSeconds = 30 # period for displaying thread monitor
@@ -298,7 +355,9 @@ class SSHotgun
     logfilename = File.basename($0) + ".#{timestr}.log"
     @filelogger = Logger.new(logfilename)
     @isFileLogging = true
+    @isDebug = false
     @isStopOnNonZeroExit = false
+    @exitCode = 0
   end
 
   # Start the processing. In most cases, this call will be the last line in
@@ -308,10 +367,11 @@ class SSHotgun
     # trap ctrl-c, show stats and exit
     trap("INT") {
       log "[_sshotgun_] info: Script terminated early by ctrl-c"
-      showRunStats
-      exit
+      showRunStatsAndExit
     }
+
     @startTime = Time.now
+    log "[_sshotgun_] info: SSHotgun version = " + @versionStr
     log "[_sshotgun_] info: Started script " + $0 + " at " + @startTime.to_s
 
     # Display configuration info
@@ -363,10 +423,8 @@ class SSHotgun
             aThread["hostname"] = hostdef.hostname  # store hostname time in threadlocal variable
             log "[_sshotgun_] info: Started thread for host = " + hostdef.hostname + " at " + aThread["threadstarttime"].to_s
             begin 
-              hostdef.startedProcess = true
               o = @processingclass.new(self, hostdef)
               o.doProcessing
-              hostdef.finishedProcess = true
             rescue => ex
               log "[_sshotgun_] stderr: Thread blew up for host = " + hostdef.hostname + ". ex = " + ex.inspect + "\n" + ex.backtrace.join("\n")
             end
@@ -424,42 +482,27 @@ class SSHotgun
 
     # ended normally, show stats
     log "[_sshotgun_] info: Script terminated normally"
-    showRunStats
+    showRunStatsAndExit
   end
 
-  # Display these status at end of script or when control-c is pressed
-  def showRunStats
-    # Display script ending message
-    stopTime = Time.now
-    log "[_sshotgun_] info: Ended script " + $0 + " at " + stopTime.to_s
-    log "[_sshotgun_] info: Elapsed script " + $0 + " time " + (stopTime - @startTime).to_s + "s"
-
-    hostarr = []
-    @hostlist.each do |hostdef| 
-      if hostdef.startedProcess == false
-        # did not start processing
-        hostarr << (hostdef.hostname + "(np)")
-      else
-        # started processing
-        if hostdef.hadNonZeroExitStatus
-          # one or more exit status were non-zero
-          hostarr << (hostdef.hostname + "(*)")
-        else
-          if hostdef.finishedProcess
-            # finished with no errors during processing
-            hostarr << hostdef.hostname
-          else
-            # Incomplete processing.  This usually means that the method threw
-            # an exception
-            hostarr << (hostdef.hostname + "(i)")
-          end
-        end
+  # Display status and exit. May be called by pressing ctrl-c, fatal error or normal termination
+  def showRunStatsAndExit
+    @threadEndMutex.synchronize {
+      # Display script ending message
+      stopTime = Time.now
+      log "[_sshotgun_] info: Ended script " + $0 + " at " + stopTime.to_s
+      log "[_sshotgun_] info: Elapsed script " + $0 + " time " + (stopTime - @startTime).to_s + "s"
+      log "[_sshotgun_] info: Script exit code is = " + @exitCode.to_s
+
+      # Display status of each host
+      @hostlist.each do |hostdef| 
+        log "[_sshotgun_] status: " + hostdef.hostname + " = " + hostdef.status
       end
-    end
-    log "[_sshotgun_] info: Status codes are '*'=had one|more non-zero exit status, 'i'=incomplete, 'np'=not started, blank=finished"
-    log "[_sshotgun_] info: Hosts summary = " + hostarr.join(", ")
+      exit @exitCode
+    }
   end
 
+
   # Log a string to the console and to the file logger
   #
   # s is the string to log
@@ -472,4 +515,5 @@ class SSHotgun
       end
     }
   end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sshotgun
 version: !ruby/object:Gem::Version 
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors: 
 - Vick Perry
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-08 00:00:00 -07:00
+date: 2008-09-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: open4
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -23,6 +24,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: highline
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -68,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: sshotgun
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A lib for writing server management scripts in Ruby. Useful for managing lots of servers.